/* Copyright 2017 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
(function(modules) {
	// webpackBootstrap
	// The module cache
	var installedModules = {};
	// The require function
	function __webpack_require__(moduleId) {
		// Check if module is in cache
		if (installedModules[moduleId]) {
			return installedModules[moduleId].exports;
		}
		// Create a new module (and put it into the cache)
		var module = installedModules[moduleId] = {
			i: moduleId,
			l: false,
			exports: {}
		};
		// Execute the module function
		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
		// Flag the module as loaded
		module.l = true;
		// Return the exports of the module
		return module.exports;
	}
	// expose the modules object (__webpack_modules__)
	__webpack_require__.m = modules;
	// expose the module cache
	__webpack_require__.c = installedModules;
	// define getter function for harmony exports
	__webpack_require__.d = function(exports, name, getter) {
		if (!__webpack_require__.o(exports, name)) {
			Object.defineProperty(exports, name, {
				configurable: false,
				enumerable: true,
				get: getter
			});
		}
	};
	// getDefaultExport function for compatibility with non-harmony modules
	__webpack_require__.n = function(module) {
		var getter = module && module.__esModule ?
			function getDefault() {
				return module['default'];
			} :
			function getModuleExports() {
				return module;
			};
		__webpack_require__.d(getter, 'a', getter);
		return getter;
	};
	// Object.prototype.hasOwnProperty.call
	__webpack_require__.o = function(object, property) {
		return Object.prototype.hasOwnProperty.call(object, property);
	};
	// __webpack_public_path__
	__webpack_require__.p = "";
	// Load entry module and return exports
	return __webpack_require__(__webpack_require__.s = 8);
})
/************************************************************************/
([
	/* 0 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.waitOnEventOrTimeout = exports.WaitOnType = exports.localized = exports.animationStarted =
			exports.normalizeWheelEventDelta = exports.binarySearchFirstItem = exports.watchScroll = exports
			.scrollIntoView = exports.getOutputScale = exports.approximateFraction = exports.roundToDivide =
			exports.getVisibleElements = exports.parseQueryString = exports.noContextMenuHandler = exports
			.getPDFFileNameFromURL = exports.ProgressBar = exports.EventBus = exports.NullL10n = exports
			.mozL10n = exports.RendererType = exports.PresentationModeState = exports.cloneObj = exports
			.isValidRotation = exports.VERTICAL_PADDING = exports.SCROLLBAR_PADDING = exports.MAX_AUTO_SCALE =
			exports.UNKNOWN_SCALE = exports.MAX_SCALE = exports.MIN_SCALE = exports.DEFAULT_SCALE = exports
			.DEFAULT_SCALE_VALUE = exports.CSS_UNITS = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
				return typeof obj;
			} :
			function(obj) {
				return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol
					.prototype ? "symbol" : typeof obj;
			};
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var CSS_UNITS = 96.0 / 72.0;
		var DEFAULT_SCALE_VALUE = 'auto';
		var DEFAULT_SCALE = 1.0;
		var MIN_SCALE = 0.05;
		var MAX_SCALE = 10.0;
		var UNKNOWN_SCALE = 0;
		var MAX_AUTO_SCALE = 1.25;
		var SCROLLBAR_PADDING = 40;
		var VERTICAL_PADDING = 5;
		var PresentationModeState = {
			UNKNOWN: 0,
			NORMAL: 1,
			CHANGING: 2,
			FULLSCREEN: 3
		};
		var RendererType = {
			CANVAS: 'canvas',
			SVG: 'svg'
		};

		function formatL10nValue(text, args) {
			if (!args) {
				return text;
			}
			return text.replace(/\{\{\s*(\w+)\s*\}\}/g, function(all, name) {
				return name in args ? args[name] : '{{' + name + '}}';
			});
		}
		var NullL10n = {
			get: function get(property, args, fallback) {
				return Promise.resolve(formatL10nValue(fallback, args));
			},
			translate: function translate(element) {
				return Promise.resolve();
			}
		};
		_pdfjsLib.PDFJS.disableFullscreen = _pdfjsLib.PDFJS.disableFullscreen === undefined ? false : _pdfjsLib
			.PDFJS.disableFullscreen;
		_pdfjsLib.PDFJS.useOnlyCssZoom = _pdfjsLib.PDFJS.useOnlyCssZoom === undefined ? false : _pdfjsLib.PDFJS
			.useOnlyCssZoom;
		_pdfjsLib.PDFJS.maxCanvasPixels = _pdfjsLib.PDFJS.maxCanvasPixels === undefined ? 16777216 : _pdfjsLib
			.PDFJS.maxCanvasPixels;
		_pdfjsLib.PDFJS.disableHistory = _pdfjsLib.PDFJS.disableHistory === undefined ? false : _pdfjsLib.PDFJS
			.disableHistory;
		_pdfjsLib.PDFJS.disableTextLayer = _pdfjsLib.PDFJS.disableTextLayer === undefined ? false : _pdfjsLib
			.PDFJS.disableTextLayer;
		_pdfjsLib.PDFJS.ignoreCurrentPositionOnZoom = _pdfjsLib.PDFJS.ignoreCurrentPositionOnZoom ===
			undefined ? false : _pdfjsLib.PDFJS.ignoreCurrentPositionOnZoom; {
			_pdfjsLib.PDFJS.locale = _pdfjsLib.PDFJS.locale === undefined && typeof navigator !== 'undefined' ?
				navigator.language : _pdfjsLib.PDFJS.locale;
		}

		function getOutputScale(ctx) {
			var devicePixelRatio = window.devicePixelRatio || 1;
			var backingStoreRatio = ctx.webkitBackingStorePixelRatio || ctx.mozBackingStorePixelRatio || ctx
				.msBackingStorePixelRatio || ctx.oBackingStorePixelRatio || ctx.backingStorePixelRatio || 1;
			var pixelRatio = devicePixelRatio / backingStoreRatio;
			return {
				sx: pixelRatio,
				sy: pixelRatio,
				scaled: pixelRatio !== 1
			};
		}

		function scrollIntoView(element, spot) {
			var skipOverflowHiddenElements = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] :
				false;
			var parent = element.offsetParent;
			if (!parent) {
				console.error('offsetParent is not set -- cannot scroll');
				return;
			}
			var offsetY = element.offsetTop + element.clientTop;
			var offsetX = element.offsetLeft + element.clientLeft;
			while (parent.clientHeight === parent.scrollHeight || skipOverflowHiddenElements &&
				getComputedStyle(parent).overflow === 'hidden') {
				if (parent.dataset._scaleY) {
					offsetY /= parent.dataset._scaleY;
					offsetX /= parent.dataset._scaleX;
				}
				offsetY += parent.offsetTop;
				offsetX += parent.offsetLeft;
				parent = parent.offsetParent;
				if (!parent) {
					return;
				}
			}
			if (spot) {
				if (spot.top !== undefined) {
					offsetY += spot.top;
				}
				if (spot.left !== undefined) {
					offsetX += spot.left;
					parent.scrollLeft = offsetX;
				}
			}
			parent.scrollTop = offsetY;
		}

		function watchScroll(viewAreaElement, callback) {
			var debounceScroll = function debounceScroll(evt) {
				if (rAF) {
					return;
				}
				rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {
					rAF = null;
					var currentY = viewAreaElement.scrollTop;
					var lastY = state.lastY;
					if (currentY !== lastY) {
						state.down = currentY > lastY;
					}
					state.lastY = currentY;
					callback(state);
				});
			};
			var state = {
				down: true,
				lastY: viewAreaElement.scrollTop,
				_eventHandler: debounceScroll
			};
			var rAF = null;
			viewAreaElement.addEventListener('scroll', debounceScroll, true);
			return state;
		}

		function parseQueryString(query) {
			var parts = query.split('&');
			var params = Object.create(null);
			for (var i = 0, ii = parts.length; i < ii; ++i) {
				var param = parts[i].split('=');
				var key = param[0].toLowerCase();
				var value = param.length > 1 ? param[1] : null;
				params[decodeURIComponent(key)] = decodeURIComponent(value);
			}
			return params;
		}

		function binarySearchFirstItem(items, condition) {
			var minIndex = 0;
			var maxIndex = items.length - 1;
			if (items.length === 0 || !condition(items[maxIndex])) {
				return items.length;
			}
			if (condition(items[minIndex])) {
				return minIndex;
			}
			while (minIndex < maxIndex) {
				var currentIndex = minIndex + maxIndex >> 1;
				var currentItem = items[currentIndex];
				if (condition(currentItem)) {
					maxIndex = currentIndex;
				} else {
					minIndex = currentIndex + 1;
				}
			}
			return minIndex;
		}

		function approximateFraction(x) {
			if (Math.floor(x) === x) {
				return [x, 1];
			}
			var xinv = 1 / x;
			var limit = 8;
			if (xinv > limit) {
				return [1, limit];
			} else if (Math.floor(xinv) === xinv) {
				return [1, xinv];
			}
			var x_ = x > 1 ? xinv : x;
			var a = 0,
				b = 1,
				c = 1,
				d = 1;
			while (true) {
				var p = a + c,
					q = b + d;
				if (q > limit) {
					break;
				}
				if (x_ <= p / q) {
					c = p;
					d = q;
				} else {
					a = p;
					b = q;
				}
			}
			var result = void 0;
			if (x_ - a / b < c / d - x_) {
				result = x_ === x ? [a, b] : [b, a];
			} else {
				result = x_ === x ? [c, d] : [d, c];
			}
			return result;
		}

		function roundToDivide(x, div) {
			var r = x % div;
			return r === 0 ? x : Math.round(x - r + div);
		}

		function getVisibleElements(scrollEl, views) {
			var sortByVisibility = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
			var top = scrollEl.scrollTop,
				bottom = top + scrollEl.clientHeight;
			var left = scrollEl.scrollLeft,
				right = left + scrollEl.clientWidth;

			function isElementBottomBelowViewTop(view) {
				var element = view.div;
				var elementBottom = element.offsetTop + element.clientTop + element.clientHeight;
				return elementBottom > top;
			}
			var visible = [],
				view = void 0,
				element = void 0;
			var currentHeight = void 0,
				viewHeight = void 0,
				hiddenHeight = void 0,
				percentHeight = void 0;
			var currentWidth = void 0,
				viewWidth = void 0;
			var firstVisibleElementInd = views.length === 0 ? 0 : binarySearchFirstItem(views,
				isElementBottomBelowViewTop);
			for (var i = firstVisibleElementInd, ii = views.length; i < ii; i++) {
				view = views[i];
				element = view.div;
				currentHeight = element.offsetTop + element.clientTop;
				viewHeight = element.clientHeight;
				if (currentHeight > bottom) {
					break;
				}
				currentWidth = element.offsetLeft + element.clientLeft;
				viewWidth = element.clientWidth;
				if (currentWidth + viewWidth < left || currentWidth > right) {
					continue;
				}
				hiddenHeight = Math.max(0, top - currentHeight) + Math.max(0, currentHeight + viewHeight -
					bottom);
				percentHeight = (viewHeight - hiddenHeight) * 100 / viewHeight | 0;
				visible.push({
					id: view.id,
					x: currentWidth,
					y: currentHeight,
					view: view,
					percent: percentHeight
				});
			}
			var first = visible[0];
			var last = visible[visible.length - 1];
			if (sortByVisibility) {
				visible.sort(function(a, b) {
					var pc = a.percent - b.percent;
					if (Math.abs(pc) > 0.001) {
						return -pc;
					}
					return a.id - b.id;
				});
			}
			return {
				first: first,
				last: last,
				views: visible
			};
		}

		function noContextMenuHandler(evt) {
			evt.preventDefault();
		}

		function isDataSchema(url) {
			var i = 0,
				ii = url.length;
			while (i < ii && url[i].trim() === '') {
				i++;
			}
			return url.substr(i, 5).toLowerCase() === 'data:';
		}

		function getPDFFileNameFromURL(url) {
			var defaultFilename = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] :
				'document.pdf';
			if (isDataSchema(url)) {
				console.warn('getPDFFileNameFromURL: ' + 'ignoring "data:" URL for performance reasons.');
				return defaultFilename;
			}
			var reURI = /^(?:(?:[^:]+:)?\/\/[^\/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
			var reFilename = /[^\/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
			var splitURI = reURI.exec(url);
			var suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename
				.exec(splitURI[3]);
			if (suggestedFilename) {
				suggestedFilename = suggestedFilename[0];
				if (suggestedFilename.indexOf('%') !== -1) {
					try {
						suggestedFilename = reFilename.exec(decodeURIComponent(suggestedFilename))[0];
					} catch (ex) {}
				}
			}
			return suggestedFilename || defaultFilename;
		}

		function normalizeWheelEventDelta(evt) {
			var delta = Math.sqrt(evt.deltaX * evt.deltaX + evt.deltaY * evt.deltaY);
			var angle = Math.atan2(evt.deltaY, evt.deltaX);
			if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
				delta = -delta;
			}
			var MOUSE_DOM_DELTA_PIXEL_MODE = 0;
			var MOUSE_DOM_DELTA_LINE_MODE = 1;
			var MOUSE_PIXELS_PER_LINE = 30;
			var MOUSE_LINES_PER_PAGE = 30;
			if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
				delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;
			} else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {
				delta /= MOUSE_LINES_PER_PAGE;
			}
			return delta;
		}

		function isValidRotation(angle) {
			return Number.isInteger(angle) && angle % 90 === 0;
		}

		function cloneObj(obj) {
			var result = Object.create(null);
			for (var i in obj) {
				if (Object.prototype.hasOwnProperty.call(obj, i)) {
					result[i] = obj[i];
				}
			}
			return result;
		}
		var WaitOnType = {
			EVENT: 'event',
			TIMEOUT: 'timeout'
		};

		function waitOnEventOrTimeout(_ref) {
			var target = _ref.target,
				name = _ref.name,
				_ref$delay = _ref.delay,
				delay = _ref$delay === undefined ? 0 : _ref$delay;
			if ((typeof target === 'undefined' ? 'undefined' : _typeof(target)) !== 'object' || !(name &&
					typeof name === 'string') || !(Number.isInteger(delay) && delay >= 0)) {
				return Promise.reject(new Error('waitOnEventOrTimeout - invalid paramaters.'));
			}
			var capability = (0,
				_pdfjsLib.createPromiseCapability)();

			function handler(type) {
				if (target instanceof EventBus) {
					target.off(name, eventHandler);
				} else {
					target.removeEventListener(name, eventHandler);
				}
				if (timeout) {
					clearTimeout(timeout);
				}
				capability.resolve(type);
			}
			var eventHandler = handler.bind(null, WaitOnType.EVENT);
			if (target instanceof EventBus) {
				target.on(name, eventHandler);
			} else {
				target.addEventListener(name, eventHandler);
			}
			var timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);
			var timeout = setTimeout(timeoutHandler, delay);
			return capability.promise;
		}
		var animationStarted = new Promise(function(resolve) {
			window.requestAnimationFrame(resolve);
		});
		var mozL10n = void 0;
		var localized = Promise.resolve();
		var EventBus = function() {
			function EventBus() {
				_classCallCheck(this, EventBus);
				this._listeners = Object.create(null);
			}
			_createClass(EventBus, [{
				key: 'on',
				value: function on(eventName, listener) {
					var eventListeners = this._listeners[eventName];
					if (!eventListeners) {
						eventListeners = [];
						this._listeners[eventName] = eventListeners;
					}
					eventListeners.push(listener);
				}
			}, {
				key: 'off',
				value: function off(eventName, listener) {
					var eventListeners = this._listeners[eventName];
					var i = void 0;
					if (!eventListeners || (i = eventListeners.indexOf(listener)) < 0) {
						return;
					}
					eventListeners.splice(i, 1);
				}
			}, {
				key: 'dispatch',
				value: function dispatch(eventName) {
					var eventListeners = this._listeners[eventName];
					if (!eventListeners || eventListeners.length === 0) {
						return;
					}
					var args = Array.prototype.slice.call(arguments, 1);
					eventListeners.slice(0).forEach(function(listener) {
						listener.apply(null, args);
					});
				}
			}]);
			return EventBus;
		}();

		function clamp(v, min, max) {
			return Math.min(Math.max(v, min), max);
		}
		var ProgressBar = function() {
			function ProgressBar(id) {
				var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
					height = _ref2.height,
					width = _ref2.width,
					units = _ref2.units;
				_classCallCheck(this, ProgressBar);
				this.visible = true;
				this.div = document.querySelector(id + ' .progress');
				this.bar = this.div.parentNode;
				this.height = height || 100;
				this.width = width || 100;
				this.units = units || '%';
				this.div.style.height = this.height + this.units;
				this.percent = 0;
			}
			_createClass(ProgressBar, [{
				key: '_updateBar',
				value: function _updateBar() {
					if (this._indeterminate) {
						this.div.classList.add('indeterminate');
						this.div.style.width = this.width + this.units;
						return;
					}
					this.div.classList.remove('indeterminate');
					var progressSize = this.width * this._percent / 100;
					this.div.style.width = progressSize + this.units;
				}
			}, {
				key: 'setWidth',
				value: function setWidth(viewer) {
					if (!viewer) {
						return;
					}
					var container = viewer.parentNode;
					var scrollbarWidth = container.offsetWidth - viewer.offsetWidth;
					if (scrollbarWidth > 0) {
						this.bar.setAttribute('style', 'width: calc(100% - ' +
							scrollbarWidth + 'px);');
					}
				}
			}, {
				key: 'hide',
				value: function hide() {
					if (!this.visible) {
						return;
					}
					this.visible = false;
					this.bar.classList.add('hidden');
					document.body.classList.remove('loadingInProgress');
				}
			}, {
				key: 'show',
				value: function show() {
					if (this.visible) {
						return;
					}
					this.visible = true;
					document.body.classList.add('loadingInProgress');
					this.bar.classList.remove('hidden');
				}
			}, {
				key: 'percent',
				get: function get() {
					return this._percent;
				},
				set: function set(val) {
					this._indeterminate = isNaN(val);
					this._percent = clamp(val, 0, 100);
					this._updateBar();
				}
			}]);
			return ProgressBar;
		}();
		exports.CSS_UNITS = CSS_UNITS;
		exports.DEFAULT_SCALE_VALUE = DEFAULT_SCALE_VALUE;
		exports.DEFAULT_SCALE = DEFAULT_SCALE;
		exports.MIN_SCALE = MIN_SCALE;
		exports.MAX_SCALE = MAX_SCALE;
		exports.UNKNOWN_SCALE = UNKNOWN_SCALE;
		exports.MAX_AUTO_SCALE = MAX_AUTO_SCALE;
		exports.SCROLLBAR_PADDING = SCROLLBAR_PADDING;
		exports.VERTICAL_PADDING = VERTICAL_PADDING;
		exports.isValidRotation = isValidRotation;
		exports.cloneObj = cloneObj;
		exports.PresentationModeState = PresentationModeState;
		exports.RendererType = RendererType;
		exports.mozL10n = mozL10n;
		exports.NullL10n = NullL10n;
		exports.EventBus = EventBus;
		exports.ProgressBar = ProgressBar;
		exports.getPDFFileNameFromURL = getPDFFileNameFromURL;
		exports.noContextMenuHandler = noContextMenuHandler;
		exports.parseQueryString = parseQueryString;
		exports.getVisibleElements = getVisibleElements;
		exports.roundToDivide = roundToDivide;
		exports.approximateFraction = approximateFraction;
		exports.getOutputScale = getOutputScale;
		exports.scrollIntoView = scrollIntoView;
		exports.watchScroll = watchScroll;
		exports.binarySearchFirstItem = binarySearchFirstItem;
		exports.normalizeWheelEventDelta = normalizeWheelEventDelta;
		exports.animationStarted = animationStarted;
		exports.localized = localized;
		exports.WaitOnType = WaitOnType;
		exports.waitOnEventOrTimeout = waitOnEventOrTimeout;
	}), /* 1 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		var pdfjsLib;
		if (typeof window !== 'undefined' && window['pdfjs-dist/build/pdf']) {
			console.log(111)
			pdfjsLib = window['pdfjs-dist/build/pdf'];
		} else {
			console.log(222)
			pdfjsLib = require('../build/pdf.js');
		}
		module.exports = pdfjsLib;
	}), /* 2 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.getGlobalEventBus = exports.attachDOMEventsToEventBus = undefined;
		var _ui_utils = __webpack_require__(0);

		function attachDOMEventsToEventBus(eventBus) {
			eventBus.on('documentload', function() {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('documentload', true, true, {});
				window.dispatchEvent(event);
			});
			eventBus.on('pagerendered', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('pagerendered', true, true, {
					pageNumber: evt.pageNumber,
					cssTransform: evt.cssTransform
				});
				evt.source.div.dispatchEvent(event);
			});
			eventBus.on('textlayerrendered', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('textlayerrendered', true, true, {
					pageNumber: evt.pageNumber
				});
				evt.source.textLayerDiv.dispatchEvent(event);
			});
			eventBus.on('pagechange', function(evt) {
				var event = document.createEvent('UIEvents');
				event.initUIEvent('pagechange', true, true, window, 0);
				event.pageNumber = evt.pageNumber;
				evt.source.container.dispatchEvent(event);
			});
			eventBus.on('pagesinit', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('pagesinit', true, true, null);
				evt.source.container.dispatchEvent(event);
			});
			eventBus.on('pagesloaded', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('pagesloaded', true, true, {
					pagesCount: evt.pagesCount
				});
				evt.source.container.dispatchEvent(event);
			});
			eventBus.on('scalechange', function(evt) {
				var event = document.createEvent('UIEvents');
				event.initUIEvent('scalechange', true, true, window, 0);
				event.scale = evt.scale;
				event.presetValue = evt.presetValue;
				evt.source.container.dispatchEvent(event);
			});
			eventBus.on('updateviewarea', function(evt) {
				var event = document.createEvent('UIEvents');
				event.initUIEvent('updateviewarea', true, true, window, 0);
				event.location = evt.location;
				evt.source.container.dispatchEvent(event);
			});
			eventBus.on('find', function(evt) {
				if (evt.source === window) {
					return;
				}
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('find' + evt.type, true, true, {
					query: evt.query,
					phraseSearch: evt.phraseSearch,
					caseSensitive: evt.caseSensitive,
					highlightAll: evt.highlightAll,
					findPrevious: evt.findPrevious
				});
				window.dispatchEvent(event);
			});
			eventBus.on('attachmentsloaded', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('attachmentsloaded', true, true, {
					attachmentsCount: evt.attachmentsCount
				});
				evt.source.container.dispatchEvent(event);
			});
			eventBus.on('sidebarviewchanged', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('sidebarviewchanged', true, true, {
					view: evt.view
				});
				evt.source.outerContainer.dispatchEvent(event);
			});
			eventBus.on('pagemode', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('pagemode', true, true, {
					mode: evt.mode
				});
				evt.source.pdfViewer.container.dispatchEvent(event);
			});
			eventBus.on('namedaction', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('namedaction', true, true, {
					action: evt.action
				});
				evt.source.pdfViewer.container.dispatchEvent(event);
			});
			eventBus.on('presentationmodechanged', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('presentationmodechanged', true, true, {
					active: evt.active,
					switchInProgress: evt.switchInProgress
				});
				window.dispatchEvent(event);
			});
			eventBus.on('outlineloaded', function(evt) {
				var event = document.createEvent('CustomEvent');
				event.initCustomEvent('outlineloaded', true, true, {
					outlineCount: evt.outlineCount
				});
				evt.source.container.dispatchEvent(event);
			});
		}
		var globalEventBus = null;

		function getGlobalEventBus() {
			if (globalEventBus) {
				return globalEventBus;
			}
			globalEventBus = new _ui_utils.EventBus();
			attachDOMEventsToEventBus(globalEventBus);
			return globalEventBus;
		}
		exports.attachDOMEventsToEventBus = attachDOMEventsToEventBus;
		exports.getGlobalEventBus = getGlobalEventBus;
	}), /* 3 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var CLEANUP_TIMEOUT = 30000;
		var RenderingStates = {
			INITIAL: 0,
			RUNNING: 1,
			PAUSED: 2,
			FINISHED: 3
		};
		var PDFRenderingQueue = function() {
			function PDFRenderingQueue() {
				_classCallCheck(this, PDFRenderingQueue);
				this.pdfViewer = null;
				this.pdfThumbnailViewer = null;
				this.onIdle = null;
				this.highestPriorityPage = null;
				this.idleTimeout = null;
				this.printing = false;
				this.isThumbnailViewEnabled = false;
			}
			_createClass(PDFRenderingQueue, [{
				key: "setViewer",
				value: function setViewer(pdfViewer) {
					this.pdfViewer = pdfViewer;
				}
			}, {
				key: "setThumbnailViewer",
				value: function setThumbnailViewer(pdfThumbnailViewer) {
					this.pdfThumbnailViewer = pdfThumbnailViewer;
				}
			}, {
				key: "isHighestPriority",
				value: function isHighestPriority(view) {
					return this.highestPriorityPage === view.renderingId;
				}
			}, {
				key: "renderHighestPriority",
				value: function renderHighestPriority(currentlyVisiblePages) {
					if (this.idleTimeout) {
						clearTimeout(this.idleTimeout);
						this.idleTimeout = null;
					}
					if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
						return;
					}
					if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {
						if (this.pdfThumbnailViewer.forceRendering()) {
							return;
						}
					}
					if (this.printing) {
						return;
					}
					if (this.onIdle) {
						this.idleTimeout = setTimeout(this.onIdle.bind(this),
							CLEANUP_TIMEOUT);
					}
				}
			}, {
				key: "getHighestPriority",
				value: function getHighestPriority(visible, views, scrolledDown) {
					var visibleViews = visible.views;
					var numVisible = visibleViews.length;
					if (numVisible === 0) {
						return false;
					}
					for (var i = 0; i < numVisible; ++i) {
						var view = visibleViews[i].view;
						if (!this.isViewFinished(view)) {
							return view;
						}
					}
					if (scrolledDown) {
						var nextPageIndex = visible.last.id;
						if (views[nextPageIndex] && !this.isViewFinished(views[
								nextPageIndex])) {
							return views[nextPageIndex];
						}
					} else {
						var previousPageIndex = visible.first.id - 2;
						if (views[previousPageIndex] && !this.isViewFinished(views[
								previousPageIndex])) {
							return views[previousPageIndex];
						}
					}
					return null;
				}
			}, {
				key: "isViewFinished",
				value: function isViewFinished(view) {
					return view.renderingState === RenderingStates.FINISHED;
				}
			}, {
				key: "renderView",
				value: function renderView(view) {
					var _this = this;
					switch (view.renderingState) {
						case RenderingStates.FINISHED:
							return false;
						case RenderingStates.PAUSED:
							this.highestPriorityPage = view.renderingId;
							view.resume();
							break;
						case RenderingStates.RUNNING:
							this.highestPriorityPage = view.renderingId;
							break;
						case RenderingStates.INITIAL:
							this.highestPriorityPage = view.renderingId;
							var continueRendering = function continueRendering() {
								_this.renderHighestPriority();
							};
							view.draw().then(continueRendering, continueRendering);
							break;
					}
					return true;
				}
			}]);
			return PDFRenderingQueue;
		}();
		exports.RenderingStates = RenderingStates;
		exports.PDFRenderingQueue = PDFRenderingQueue;
	}), /* 4 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFPrintServiceFactory = exports.DefaultExternalServices = exports.PDFViewerApplication =
			undefined;
		var _slicedToArray = function() {
			function sliceIterator(arr, i) {
				var _arr = [];
				var _n = true;
				var _d = false;
				var _e = undefined;
				try {
					for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
						_arr.push(_s.value);
						if (i && _arr.length === i)
							break;
					}
				} catch (err) {
					_d = true;
					_e = err;
				} finally {
					try {
						if (!_n && _i["return"])
							_i["return"]();
					} finally {
						if (_d)
							throw _e;
					}
				}
				return _arr;
			}
			return function(arr, i) {
				if (Array.isArray(arr)) {
					return arr;
				} else if (Symbol.iterator in Object(arr)) {
					return sliceIterator(arr, i);
				} else {
					throw new TypeError("Invalid attempt to destructure non-iterable instance");
				}
			};
		}();
		var _ui_utils = __webpack_require__(0);
		var _pdfjsLib = __webpack_require__(1);
		var _pdf_cursor_tools = __webpack_require__(6);
		var _pdf_rendering_queue = __webpack_require__(3);
		var _pdf_sidebar = __webpack_require__(10);
		var _dom_events = __webpack_require__(2);
		var _overlay_manager = __webpack_require__(11);
		var _password_prompt = __webpack_require__(12);
		var _pdf_attachment_viewer = __webpack_require__(13);
		var _pdf_document_properties = __webpack_require__(14);
		var _pdf_find_bar = __webpack_require__(15);
		var _pdf_find_controller = __webpack_require__(7);
		var _pdf_history = __webpack_require__(16);
		var _pdf_link_service = __webpack_require__(5);
		var _pdf_outline_viewer = __webpack_require__(17);
		var _pdf_presentation_mode = __webpack_require__(18);
		var _pdf_thumbnail_viewer = __webpack_require__(19);
		var _pdf_viewer = __webpack_require__(21);
		var _secondary_toolbar = __webpack_require__(26);
		var _toolbar = __webpack_require__(27);
		var _view_history = __webpack_require__(28);
		var DEFAULT_SCALE_DELTA = 1.1;
		var DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT = 5000;

		function configure(PDFJS) {
			PDFJS.imageResourcesPath = './images/';
			PDFJS.workerSrc = './pdf.js/pdf.worker.js';
			PDFJS.cMapUrl = './cmaps/';
			PDFJS.cMapPacked = true;
		}
		var DefaultExternalServices = {
			updateFindControlState: function updateFindControlState(data) {},
			initPassiveLoading: function initPassiveLoading(callbacks) {},
			fallback: function fallback(data, callback) {},
			reportTelemetry: function reportTelemetry(data) {},
			createDownloadManager: function createDownloadManager() {
				throw new Error('Not implemented: createDownloadManager');
			},
			createPreferences: function createPreferences() {
				throw new Error('Not implemented: createPreferences');
			},
			createL10n: function createL10n() {
				throw new Error('Not implemented: createL10n');
			},
			supportsIntegratedFind: false,
			supportsDocumentFonts: true,
			supportsDocumentColors: true,
			supportedMouseWheelZoomModifierKeys: {
				ctrlKey: true,
				metaKey: true
			}
		};
		var PDFViewerApplication = {
			initialBookmark: document.location.hash.substring(1),
			initialized: false,
			fellback: false,
			appConfig: null,
			pdfDocument: null,
			pdfLoadingTask: null,
			printService: null,
			pdfViewer: null,
			pdfThumbnailViewer: null,
			pdfRenderingQueue: null,
			pdfPresentationMode: null,
			pdfDocumentProperties: null,
			pdfLinkService: null,
			pdfHistory: null,
			pdfSidebar: null,
			pdfOutlineViewer: null,
			pdfAttachmentViewer: null,
			pdfCursorTools: null,
			store: null,
			downloadManager: null,
			overlayManager: null,
			preferences: null,
			toolbar: null,
			secondaryToolbar: null,
			eventBus: null,
			l10n: null,
			isInitialViewSet: false,
			downloadComplete: false,
			viewerPrefs: {
				sidebarViewOnLoad: _pdf_sidebar.SidebarView.NONE,
				pdfBugEnabled: false,
				showPreviousViewOnLoad: true,
				defaultZoomValue: '',
				disablePageMode: false,
				disablePageLabels: false,
				renderer: 'canvas',
				enhanceTextSelection: false,
				renderInteractiveForms: false,
				enablePrintAutoRotate: false
			},
			isViewerEmbedded: window.parent !== window,
			url: '',
			baseUrl: '',
			externalServices: DefaultExternalServices,
			_boundEvents: {},
			initialize: function initialize(appConfig) {
				var _this = this;
				this.preferences = this.externalServices.createPreferences();
				configure(_pdfjsLib.PDFJS);
				this.appConfig = appConfig;
				return this._readPreferences().then(function() {
					return _this._initializeL10n();
				}).then(function() {
					return _this._initializeViewerComponents();
				}).then(function() {
					_this.bindEvents();
					_this.bindWindowEvents();
					var appContainer = appConfig.appContainer || document.documentElement;
					_this.l10n.translate(appContainer).then(function() {
						_this.eventBus.dispatch('localized');
					});
					if (_this.isViewerEmbedded && !_pdfjsLib.PDFJS.isExternalLinkTargetSet()) {
						_pdfjsLib.PDFJS.externalLinkTarget = _pdfjsLib.PDFJS.LinkTarget.TOP;
					}
					_this.initialized = true;
				});
			},
			_readPreferences: function _readPreferences() {
				var preferences = this.preferences,
					viewerPrefs = this.viewerPrefs;
				return Promise.all([preferences.get('enableWebGL').then(function resolved(value) {
					_pdfjsLib.PDFJS.disableWebGL = !value;
				}), preferences.get('sidebarViewOnLoad').then(function resolved(value) {
					viewerPrefs['sidebarViewOnLoad'] = value;
				}), preferences.get('pdfBugEnabled').then(function resolved(value) {
					viewerPrefs['pdfBugEnabled'] = value;
				}), preferences.get('showPreviousViewOnLoad').then(function resolved(
				value) {
					viewerPrefs['showPreviousViewOnLoad'] = value;
				}), preferences.get('defaultZoomValue').then(function resolved(value) {
					viewerPrefs['defaultZoomValue'] = value;
				}), preferences.get('enhanceTextSelection').then(function resolved(value) {
					viewerPrefs['enhanceTextSelection'] = value;
				}), preferences.get('disableTextLayer').then(function resolved(value) {
					if (_pdfjsLib.PDFJS.disableTextLayer === true) {
						return;
					}
					_pdfjsLib.PDFJS.disableTextLayer = value;
				}), preferences.get('disableRange').then(function resolved(value) {
					if (_pdfjsLib.PDFJS.disableRange === true) {
						return;
					}
					_pdfjsLib.PDFJS.disableRange = value;
				}), preferences.get('disableStream').then(function resolved(value) {
					if (_pdfjsLib.PDFJS.disableStream === true) {
						return;
					}
					_pdfjsLib.PDFJS.disableStream = value;
				}), preferences.get('disableAutoFetch').then(function resolved(value) {
					_pdfjsLib.PDFJS.disableAutoFetch = value;
				}), preferences.get('disableFontFace').then(function resolved(value) {
					if (_pdfjsLib.PDFJS.disableFontFace === true) {
						return;
					}
					_pdfjsLib.PDFJS.disableFontFace = value;
				}), preferences.get('useOnlyCssZoom').then(function resolved(value) {
					_pdfjsLib.PDFJS.useOnlyCssZoom = value;
				}), preferences.get('externalLinkTarget').then(function resolved(value) {
					if (_pdfjsLib.PDFJS.isExternalLinkTargetSet()) {
						return;
					}
					_pdfjsLib.PDFJS.externalLinkTarget = value;
				}), preferences.get('renderer').then(function resolved(value) {
					viewerPrefs['renderer'] = value;
				}), preferences.get('renderInteractiveForms').then(function resolved(
				value) {
					viewerPrefs['renderInteractiveForms'] = value;
				}), preferences.get('disablePageMode').then(function resolved(value) {
					viewerPrefs['disablePageMode'] = value;
				}), preferences.get('disablePageLabels').then(function resolved(value) {
					viewerPrefs['disablePageLabels'] = value;
				}), preferences.get('enablePrintAutoRotate').then(function resolved(value) {
					viewerPrefs['enablePrintAutoRotate'] = value;
				})]).catch(function(reason) {});
			},
			_initializeL10n: function _initializeL10n() {
				if (this.viewerPrefs['pdfBugEnabled']) {
					var hash = document.location.hash.substring(1);
					var hashParams = (0,
						_ui_utils.parseQueryString)(hash);
					if ('locale' in hashParams) {
						_pdfjsLib.PDFJS.locale = hashParams['locale'];
					}
				}
				this.l10n = this.externalServices.createL10n();
				return this.l10n.getDirection().then(function(dir) {
					document.getElementsByTagName('html')[0].dir = dir;
				});
			},
			_initializeViewerComponents: function _initializeViewerComponents() {
				var _this2 = this;
				var appConfig = this.appConfig;
				return new Promise(function(resolve, reject) {
					_this2.overlayManager = new _overlay_manager.OverlayManager();
					var eventBus = appConfig.eventBus || (0,
						_dom_events.getGlobalEventBus)();
					_this2.eventBus = eventBus;
					var pdfRenderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
					pdfRenderingQueue.onIdle = _this2.cleanup.bind(_this2);
					_this2.pdfRenderingQueue = pdfRenderingQueue;
					var pdfLinkService = new _pdf_link_service.PDFLinkService({
						eventBus: eventBus
					});
					_this2.pdfLinkService = pdfLinkService;
					var downloadManager = _this2.externalServices.createDownloadManager();
					_this2.downloadManager = downloadManager;
					var container = appConfig.mainContainer;
					var viewer = appConfig.viewerContainer;
					_this2.pdfViewer = new _pdf_viewer.PDFViewer({
						container: container,
						viewer: viewer,
						eventBus: eventBus,
						renderingQueue: pdfRenderingQueue,
						linkService: pdfLinkService,
						downloadManager: downloadManager,
						renderer: _this2.viewerPrefs['renderer'],
						l10n: _this2.l10n,
						enhanceTextSelection: _this2.viewerPrefs[
							'enhanceTextSelection'],
						renderInteractiveForms: _this2.viewerPrefs[
							'renderInteractiveForms'],
						enablePrintAutoRotate: _this2.viewerPrefs[
							'enablePrintAutoRotate']
					});
					pdfRenderingQueue.setViewer(_this2.pdfViewer);
					pdfLinkService.setViewer(_this2.pdfViewer);
					var thumbnailContainer = appConfig.sidebar.thumbnailView;
					_this2.pdfThumbnailViewer = new _pdf_thumbnail_viewer.PDFThumbnailViewer({
						container: thumbnailContainer,
						renderingQueue: pdfRenderingQueue,
						linkService: pdfLinkService,
						l10n: _this2.l10n
					});
					pdfRenderingQueue.setThumbnailViewer(_this2.pdfThumbnailViewer);
					_this2.pdfHistory = new _pdf_history.PDFHistory({
						linkService: pdfLinkService,
						eventBus: eventBus
					});
					pdfLinkService.setHistory(_this2.pdfHistory);
					_this2.findController = new _pdf_find_controller.PDFFindController({
						pdfViewer: _this2.pdfViewer
					});
					_this2.findController.onUpdateResultsCount = function(matchCount) {
						if (_this2.supportsIntegratedFind) {
							return;
						}
						_this2.findBar.updateResultsCount(matchCount);
					};
					_this2.findController.onUpdateState = function(state, previous,
					matchCount) {
						if (_this2.supportsIntegratedFind) {
							_this2.externalServices.updateFindControlState({
								result: state,
								findPrevious: previous
							});
						} else {
							_this2.findBar.updateUIState(state, previous, matchCount);
						}
					};
					_this2.pdfViewer.setFindController(_this2.findController);
					var findBarConfig = Object.create(appConfig.findBar);
					findBarConfig.findController = _this2.findController;
					findBarConfig.eventBus = eventBus;
					_this2.findBar = new _pdf_find_bar.PDFFindBar(findBarConfig, _this2.l10n);
					_this2.pdfDocumentProperties = new _pdf_document_properties
						.PDFDocumentProperties(appConfig.documentProperties, _this2
							.overlayManager, _this2.l10n);
					_this2.pdfCursorTools = new _pdf_cursor_tools.PDFCursorTools({
						container: container,
						eventBus: eventBus,
						preferences: _this2.preferences
					});
					_this2.toolbar = new _toolbar.Toolbar(appConfig.toolbar, container,
						eventBus, _this2.l10n);
					_this2.secondaryToolbar = new _secondary_toolbar.SecondaryToolbar(appConfig
						.secondaryToolbar, container, eventBus);
					if (_this2.supportsFullscreen) {
						_this2.pdfPresentationMode = new _pdf_presentation_mode
							.PDFPresentationMode({
								container: container,
								viewer: viewer,
								pdfViewer: _this2.pdfViewer,
								eventBus: eventBus,
								contextMenuItems: appConfig.fullscreen
							});
					}
					_this2.passwordPrompt = new _password_prompt.PasswordPrompt(appConfig
						.passwordOverlay, _this2.overlayManager, _this2.l10n);
					_this2.pdfOutlineViewer = new _pdf_outline_viewer.PDFOutlineViewer({
						container: appConfig.sidebar.outlineView,
						eventBus: eventBus,
						linkService: pdfLinkService
					});
					_this2.pdfAttachmentViewer = new _pdf_attachment_viewer
				.PDFAttachmentViewer({
						container: appConfig.sidebar.attachmentsView,
						eventBus: eventBus,
						downloadManager: downloadManager
					});
					var sidebarConfig = Object.create(appConfig.sidebar);
					sidebarConfig.pdfViewer = _this2.pdfViewer;
					sidebarConfig.pdfThumbnailViewer = _this2.pdfThumbnailViewer;
					sidebarConfig.pdfOutlineViewer = _this2.pdfOutlineViewer;
					sidebarConfig.eventBus = eventBus;
					_this2.pdfSidebar = new _pdf_sidebar.PDFSidebar(sidebarConfig, _this2.l10n);
					_this2.pdfSidebar.onToggled = _this2.forceRendering.bind(_this2);
					resolve(undefined);
				});
			},
			run: function run(config) {
				this.initialize(config).then(webViewerInitialized);
			},
			zoomIn: function zoomIn(ticks) {
				var newScale = this.pdfViewer.currentScale;
				do {
					newScale = (newScale * DEFAULT_SCALE_DELTA).toFixed(2);
					newScale = Math.ceil(newScale * 10) / 10;
					newScale = Math.min(_ui_utils.MAX_SCALE, newScale);
				} while (--ticks > 0 && newScale < _ui_utils.MAX_SCALE);
				this.pdfViewer.currentScaleValue = newScale;
			},
			zoomOut: function zoomOut(ticks) {
				var newScale = this.pdfViewer.currentScale;
				do {
					newScale = (newScale / DEFAULT_SCALE_DELTA).toFixed(2);
					newScale = Math.floor(newScale * 10) / 10;
					newScale = Math.max(_ui_utils.MIN_SCALE, newScale);
				} while (--ticks > 0 && newScale > _ui_utils.MIN_SCALE);
				this.pdfViewer.currentScaleValue = newScale;
			},
			get pagesCount() {
				return this.pdfDocument ? this.pdfDocument.numPages : 0;
			},
			get pageRotation() {
				return this.pdfViewer.pagesRotation;
			},
			set page(val) {
				this.pdfViewer.currentPageNumber = val;
			},
			get page() {
				return this.pdfViewer.currentPageNumber;
			},
			get printing() {
				return !!this.printService;
			},
			get supportsPrinting() {
				return PDFPrintServiceFactory.instance.supportsPrinting;
			},
			get supportsFullscreen() {
				var support = void 0;
				var doc = document.documentElement;
				support = !!(doc.requestFullscreen || doc.mozRequestFullScreen || doc
					.webkitRequestFullScreen || doc.msRequestFullscreen);
				if (document.fullscreenEnabled === false || document.mozFullScreenEnabled === false ||
					document.webkitFullscreenEnabled === false || document.msFullscreenEnabled === false
					) {
					support = false;
				}
				if (support && _pdfjsLib.PDFJS.disableFullscreen === true) {
					support = false;
				}
				return (0,
					_pdfjsLib.shadow)(this, 'supportsFullscreen', support);
			},
			get supportsIntegratedFind() {
				return this.externalServices.supportsIntegratedFind;
			},
			get supportsDocumentFonts() {
				return this.externalServices.supportsDocumentFonts;
			},
			get supportsDocumentColors() {
				return this.externalServices.supportsDocumentColors;
			},
			get loadingBar() {
				var bar = new _ui_utils.ProgressBar('#loadingBar');
				return (0,
					_pdfjsLib.shadow)(this, 'loadingBar', bar);
			},
			get supportedMouseWheelZoomModifierKeys() {
				return this.externalServices.supportedMouseWheelZoomModifierKeys;
			},
			initPassiveLoading: function initPassiveLoading() {
				throw new Error('Not implemented: initPassiveLoading');
			},
			setTitleUsingUrl: function setTitleUsingUrl(url) {
				this.url = url;
				this.baseUrl = url.split('#')[0];
				var title = (0,
					_ui_utils.getPDFFileNameFromURL)(url, '');
				if (!title) {
					try {
						title = decodeURIComponent((0,
							_pdfjsLib.getFilenameFromUrl)(url)) || url;
					} catch (ex) {
						title = url;
					}
				}
				this.setTitle(title);
			},
			setTitle: function setTitle(title) {
				if (this.isViewerEmbedded) {
					return;
				}
				document.title = title;
			},
			close: function close() {
				var errorWrapper = this.appConfig.errorWrapper.container;
				errorWrapper.setAttribute('hidden', 'true');
				if (!this.pdfLoadingTask) {
					return Promise.resolve();
				}
				var promise = this.pdfLoadingTask.destroy();
				this.pdfLoadingTask = null;
				if (this.pdfDocument) {
					this.pdfDocument = null;
					this.pdfThumbnailViewer.setDocument(null);
					this.pdfViewer.setDocument(null);
					this.pdfLinkService.setDocument(null, null);
					this.pdfDocumentProperties.setDocument(null, null);
				}
				this.store = null;
				this.isInitialViewSet = false;
				this.downloadComplete = false;
				this.pdfSidebar.reset();
				this.pdfOutlineViewer.reset();
				this.pdfAttachmentViewer.reset();
				this.findController.reset();
				this.findBar.reset();
				this.toolbar.reset();
				this.secondaryToolbar.reset();
				if (typeof PDFBug !== 'undefined') {
					PDFBug.cleanup();
				}
				return promise;
			},
			open: function open(file, args) {
				var _this3 = this;
				if (arguments.length > 2 || typeof args === 'number') {
					return Promise.reject(new Error('Call of open() with obsolete signature.'));
				}
				if (this.pdfLoadingTask) {
					return this.close().then(function() {
						_this3.preferences.reload();
						return _this3.open(file, args);
					});
				}
				var parameters = Object.create(null);
				if (typeof file === 'string') {
					this.setTitleUsingUrl(file);
					parameters.url = file;
				} else if (file && 'byteLength' in file) {
					parameters.data = file;
				} else if (file.url && file.originalUrl) {
					this.setTitleUsingUrl(file.originalUrl);
					parameters.url = file.url;
				}
				if (args) {
					for (var prop in args) {
						if (!_pdfjsLib.PDFJS.pdfjsNext && prop === 'scale') {
							console.error('Call of open() with obsolete "scale" argument, ' +
								'please use the "defaultZoomValue" preference instead.');
							continue;
						} else if (prop === 'length') {
							this.pdfDocumentProperties.setFileSize(args[prop]);
						}
						parameters[prop] = args[prop];
					}
				}
				var loadingTask = (0,
					_pdfjsLib.getDocument)(parameters);
				this.pdfLoadingTask = loadingTask;
				loadingTask.onPassword = function(updateCallback, reason) {
					_this3.passwordPrompt.setUpdateCallback(updateCallback, reason);
					_this3.passwordPrompt.open();
				};
				loadingTask.onProgress = function(_ref) {
					var loaded = _ref.loaded,
						total = _ref.total;
					_this3.progress(loaded / total);
				};
				loadingTask.onUnsupportedFeature = this.fallback.bind(this);
				return loadingTask.promise.then(function(pdfDocument) {
					_this3.load(pdfDocument);
				}, function(exception) {
					var message = exception && exception.message;
					var loadingErrorMessage = void 0;
					if (exception instanceof _pdfjsLib.InvalidPDFException) {
						loadingErrorMessage = _this3.l10n.get('invalid_file_error', null,
							'Invalid or corrupted PDF file.');
					} else if (exception instanceof _pdfjsLib.MissingPDFException) {
						loadingErrorMessage = _this3.l10n.get('missing_file_error', null,
							'Missing PDF file.');
					} else if (exception instanceof _pdfjsLib.UnexpectedResponseException) {
						loadingErrorMessage = _this3.l10n.get('unexpected_response_error', null,
							'Unexpected server response.');
					} else {
						loadingErrorMessage = _this3.l10n.get('loading_error', null,
							'An error occurred while loading the PDF.');
					}
					return loadingErrorMessage.then(function(msg) {
						_this3.error(msg, {
							message: message
						});
						throw new Error(msg);
					});
				});
			},
			download: function download() {
				var _this4 = this;

				function downloadByUrl() {
					downloadManager.downloadUrl(url, filename);
				}
				var url = this.baseUrl;
				var filename = (0,
					_ui_utils.getPDFFileNameFromURL)(this.url);
				var downloadManager = this.downloadManager;
				downloadManager.onerror = function(err) {
					_this4.error('PDF failed to download: ' + err);
				};
				if (!this.pdfDocument || !this.downloadComplete) {
					downloadByUrl();
					return;
				}
				this.pdfDocument.getData().then(function(data) {
					var blob = (0,
						_pdfjsLib.createBlob)(data, 'application/pdf');
					downloadManager.download(blob, url, filename);
				}).catch(downloadByUrl);
			},
			fallback: function fallback(featureId) {},
			error: function error(message, moreInfo) {
				var moreInfoText = [this.l10n.get('error_version_info', {
					version: _pdfjsLib.version || '?',
					build: _pdfjsLib.build || '?'
				}, 'PDF.js v{{version}} (build: {{build}})')];
				if (moreInfo) {
					moreInfoText.push(this.l10n.get('error_message', {
						message: moreInfo.message
					}, 'Message: {{message}}'));
					if (moreInfo.stack) {
						moreInfoText.push(this.l10n.get('error_stack', {
							stack: moreInfo.stack
						}, 'Stack: {{stack}}'));
					} else {
						if (moreInfo.filename) {
							moreInfoText.push(this.l10n.get('error_file', {
								file: moreInfo.filename
							}, 'File: {{file}}'));
						}
						if (moreInfo.lineNumber) {
							moreInfoText.push(this.l10n.get('error_line', {
								line: moreInfo.lineNumber
							}, 'Line: {{line}}'));
						}
					}
				}
				var errorWrapperConfig = this.appConfig.errorWrapper;
				var errorWrapper = errorWrapperConfig.container;
				errorWrapper.removeAttribute('hidden');
				var errorMessage = errorWrapperConfig.errorMessage;
				errorMessage.textContent = message;
				var closeButton = errorWrapperConfig.closeButton;
				closeButton.onclick = function() {
					errorWrapper.setAttribute('hidden', 'true');
				};
				var errorMoreInfo = errorWrapperConfig.errorMoreInfo;
				var moreInfoButton = errorWrapperConfig.moreInfoButton;
				var lessInfoButton = errorWrapperConfig.lessInfoButton;
				moreInfoButton.onclick = function() {
					errorMoreInfo.removeAttribute('hidden');
					moreInfoButton.setAttribute('hidden', 'true');
					lessInfoButton.removeAttribute('hidden');
					errorMoreInfo.style.height = errorMoreInfo.scrollHeight + 'px';
				};
				lessInfoButton.onclick = function() {
					errorMoreInfo.setAttribute('hidden', 'true');
					moreInfoButton.removeAttribute('hidden');
					lessInfoButton.setAttribute('hidden', 'true');
				};
				moreInfoButton.oncontextmenu = _ui_utils.noContextMenuHandler;
				lessInfoButton.oncontextmenu = _ui_utils.noContextMenuHandler;
				closeButton.oncontextmenu = _ui_utils.noContextMenuHandler;
				moreInfoButton.removeAttribute('hidden');
				lessInfoButton.setAttribute('hidden', 'true');
				Promise.all(moreInfoText).then(function(parts) {
					errorMoreInfo.value = parts.join('\n');
				});
			},
			progress: function progress(level) {
				var _this5 = this;
				if (this.downloadComplete) {
					return;
				}
				var percent = Math.round(level * 100);
				if (percent > this.loadingBar.percent || isNaN(percent)) {
					this.loadingBar.percent = percent;
					if (_pdfjsLib.PDFJS.disableAutoFetch && percent) {
						if (this.disableAutoFetchLoadingBarTimeout) {
							clearTimeout(this.disableAutoFetchLoadingBarTimeout);
							this.disableAutoFetchLoadingBarTimeout = null;
						}
						this.loadingBar.show();
						this.disableAutoFetchLoadingBarTimeout = setTimeout(function() {
							_this5.loadingBar.hide();
							_this5.disableAutoFetchLoadingBarTimeout = null;
						}, DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT);
					}
				}
			},
			load: function load(pdfDocument) {
				var _this6 = this;
				this.pdfDocument = pdfDocument;
				pdfDocument.getDownloadInfo().then(function() {
					_this6.downloadComplete = true;
					_this6.loadingBar.hide();
					firstPagePromise.then(function() {
						_this6.eventBus.dispatch('documentload', {
							source: _this6
						});
					});
				});
				var pageModePromise = pdfDocument.getPageMode().catch(function() {});
				this.toolbar.setPagesCount(pdfDocument.numPages, false);
				this.secondaryToolbar.setPagesCount(pdfDocument.numPages);
				var id = this.documentFingerprint = pdfDocument.fingerprint;
				var store = this.store = new _view_history.ViewHistory(id);
				var baseDocumentUrl = void 0;
				baseDocumentUrl = null;
				this.pdfLinkService.setDocument(pdfDocument, baseDocumentUrl);
				this.pdfDocumentProperties.setDocument(pdfDocument, this.url);
				var pdfViewer = this.pdfViewer;
				pdfViewer.setDocument(pdfDocument);
				var firstPagePromise = pdfViewer.firstPagePromise;
				var pagesPromise = pdfViewer.pagesPromise;
				var onePageRendered = pdfViewer.onePageRendered;
				var pdfThumbnailViewer = this.pdfThumbnailViewer;
				pdfThumbnailViewer.setDocument(pdfDocument);
				firstPagePromise.then(function(pdfPage) {
					_this6.loadingBar.setWidth(_this6.appConfig.viewerContainer);
					if (!_pdfjsLib.PDFJS.disableHistory && !_this6.isViewerEmbedded) {
						var resetHistory = !_this6.viewerPrefs['showPreviousViewOnLoad'];
						_this6.pdfHistory.initialize(id, resetHistory);
						if (_this6.pdfHistory.initialBookmark) {
							_this6.initialBookmark = _this6.pdfHistory.initialBookmark;
							_this6.initialRotation = _this6.pdfHistory.initialRotation;
						}
					}
					var initialParams = {
						bookmark: null,
						hash: null
					};
					var storePromise = store.getMultiple({
						exists: false,
						page: '1',
						zoom: _ui_utils.DEFAULT_SCALE_VALUE,
						scrollLeft: '0',
						scrollTop: '0',
						rotation: null,
						sidebarView: _pdf_sidebar.SidebarView.NONE
					}).catch(function() {});
					Promise.all([storePromise, pageModePromise]).then(function(_ref2) {
						var _ref3 = _slicedToArray(_ref2, 2),
							_ref3$ = _ref3[0],
							values = _ref3$ === undefined ? {} : _ref3$,
							pageMode = _ref3[1];
						var hash = _this6.viewerPrefs['defaultZoomValue'] ? 'zoom=' +
							_this6.viewerPrefs['defaultZoomValue'] : null;
						var rotation = null;
						var sidebarView = _this6.viewerPrefs['sidebarViewOnLoad'];
						if (values.exists && _this6.viewerPrefs[
								'showPreviousViewOnLoad']) {
							hash = 'page=' + values.page + '&zoom=' + (_this6
									.viewerPrefs['defaultZoomValue'] || values.zoom) +
								',' + values.scrollLeft + ',' + values.scrollTop;
							rotation = parseInt(values.rotation, 10);
							sidebarView = sidebarView || values.sidebarView | 0;
						}
						if (pageMode && !_this6.viewerPrefs['disablePageMode']) {
							sidebarView = sidebarView || apiPageModeToSidebarView(
								pageMode);
						}
						return {
							hash: hash,
							rotation: rotation,
							sidebarView: sidebarView
						};
					}).then(function(_ref4) {
						var hash = _ref4.hash,
							rotation = _ref4.rotation,
							sidebarView = _ref4.sidebarView;
						initialParams.bookmark = _this6.initialBookmark;
						initialParams.hash = hash;
						_this6.setInitialView(hash, {
							rotation: rotation,
							sidebarView: sidebarView
						});
						if (!_this6.isViewerEmbedded) {
							pdfViewer.focus();
						}
						return pagesPromise;
					}).then(function() {
						if (!initialParams.bookmark && !initialParams.hash) {
							return;
						}
						if (pdfViewer.hasEqualPageSizes) {
							return;
						}
						_this6.initialBookmark = initialParams.bookmark;
						pdfViewer.currentScaleValue = pdfViewer.currentScaleValue;
						_this6.setInitialView(initialParams.hash);
					}).then(function() {
						pdfViewer.update();
					});
				});
				pdfDocument.getPageLabels().then(function(labels) {
					if (!labels || _this6.viewerPrefs['disablePageLabels']) {
						return;
					}
					var i = 0,
						numLabels = labels.length;
					if (numLabels !== _this6.pagesCount) {
						console.error('The number of Page Labels does not match ' +
							'the number of pages in the document.');
						return;
					}
					while (i < numLabels && labels[i] === (i + 1).toString()) {
						i++;
					}
					if (i === numLabels) {
						return;
					}
					pdfViewer.setPageLabels(labels);
					pdfThumbnailViewer.setPageLabels(labels);
					_this6.toolbar.setPagesCount(pdfDocument.numPages, true);
					_this6.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer
						.currentPageLabel);
				});
				pagesPromise.then(function() {
					if (!_this6.supportsPrinting) {
						return;
					}
					pdfDocument.getJavaScript().then(function(javaScript) {
						if (javaScript.length === 0) {
							return;
						}
						javaScript.some(function(js) {
							if (!js) {
								return false;
							}
							console.warn(
							'Warning: JavaScript is not supported');
							_this6.fallback(_pdfjsLib.UNSUPPORTED_FEATURES
								.javaScript);
							return true;
						});
						var regex = /\bprint\s*\(/;
						for (var i = 0, ii = javaScript.length; i < ii; i++) {
							var js = javaScript[i];
							if (js && regex.test(js)) {
								setTimeout(function() {
									window.print();
								});
								return;
							}
						}
					});
				});
				Promise.all([onePageRendered, _ui_utils.animationStarted]).then(function() {
					pdfDocument.getOutline().then(function(outline) {
						_this6.pdfOutlineViewer.render({
							outline: outline
						});
					});
					pdfDocument.getAttachments().then(function(attachments) {
						_this6.pdfAttachmentViewer.render({
							attachments: attachments
						});
					});
				});
				pdfDocument.getMetadata().then(function(_ref5) {
					var info = _ref5.info,
						metadata = _ref5.metadata;
					_this6.documentInfo = info;
					_this6.metadata = metadata;
					console.log('PDF ' + pdfDocument.fingerprint + ' [' + info
						.PDFFormatVersion + ' ' + (info.Producer || '-').trim() + ' / ' + (
							info.Creator || '-').trim() + ']' + ' (PDF.js: ' + (_pdfjsLib
							.version || '-') + (!_pdfjsLib.PDFJS.disableWebGL ? ' [WebGL]' :
							'') + ')');
					var pdfTitle = void 0;
					if (metadata && metadata.has('dc:title')) {
						var title = metadata.get('dc:title');
						if (title !== 'Untitled') {
							pdfTitle = title;
						}
					}
					if (!pdfTitle && info && info['Title']) {
						pdfTitle = info['Title'];
					}
					if (pdfTitle) {
						_this6.setTitle(pdfTitle + ' - ' + document.title);
					}
					if (info.IsAcroFormPresent) {
						console.warn('Warning: AcroForm/XFA is not supported');
						_this6.fallback(_pdfjsLib.UNSUPPORTED_FEATURES.forms);
					}
				});
			},
			setInitialView: function setInitialView(storedHash) {
				var _this7 = this;
				var _ref6 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
					rotation = _ref6.rotation,
					sidebarView = _ref6.sidebarView;
				var setRotation = function setRotation(angle) {
					if ((0,
							_ui_utils.isValidRotation)(angle)) {
						_this7.pdfViewer.pagesRotation = angle;
					}
				};
				this.isInitialViewSet = true;
				this.pdfSidebar.setInitialView(sidebarView);
				if (this.initialBookmark) {
					setRotation(this.initialRotation);
					delete this.initialRotation;
					this.pdfLinkService.setHash(this.initialBookmark);
					this.initialBookmark = null;
				} else if (storedHash) {
					setRotation(rotation);
					this.pdfLinkService.setHash(storedHash);
				}
				this.toolbar.setPageNumber(this.pdfViewer.currentPageNumber, this.pdfViewer
					.currentPageLabel);
				this.secondaryToolbar.setPageNumber(this.pdfViewer.currentPageNumber);
				if (!this.pdfViewer.currentScaleValue) {
					this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
				}
			},
			cleanup: function cleanup() {
				if (!this.pdfDocument) {
					return;
				}
				this.pdfViewer.cleanup();
				this.pdfThumbnailViewer.cleanup();
				if (this.pdfViewer.renderer !== _ui_utils.RendererType.SVG) {
					this.pdfDocument.cleanup();
				}
			},
			forceRendering: function forceRendering() {
				this.pdfRenderingQueue.printing = this.printing;
				this.pdfRenderingQueue.isThumbnailViewEnabled = this.pdfSidebar.isThumbnailViewVisible;
				this.pdfRenderingQueue.renderHighestPriority();
			},
			beforePrint: function beforePrint() {
				var _this8 = this;
				if (this.printService) {
					return;
				}
				if (!this.supportsPrinting) {
					this.l10n.get('printing_not_supported', null,
						'Warning: Printing is not fully supported by ' + 'this browser.').then(
						function(printMessage) {
							_this8.error(printMessage);
						});
					return;
				}
				if (!this.pdfViewer.pageViewsReady) {
					this.l10n.get('printing_not_ready', null,
						'Warning: The PDF is not fully loaded for printing.').then(function(
						notReadyMessage) {
						window.alert(notReadyMessage);
					});
					return;
				}
				var pagesOverview = this.pdfViewer.getPagesOverview();
				var printContainer = this.appConfig.printContainer;
				var printService = PDFPrintServiceFactory.instance.createPrintService(this.pdfDocument,
					pagesOverview, printContainer, this.l10n);
				this.printService = printService;
				this.forceRendering();
				printService.layout();
			},
			afterPrint: function pdfViewSetupAfterPrint() {
				if (this.printService) {
					this.printService.destroy();
					this.printService = null;
				}
				this.forceRendering();
			},
			rotatePages: function rotatePages(delta) {
				if (!this.pdfDocument) {
					return;
				}
				var newRotation = (this.pdfViewer.pagesRotation + 360 + delta) % 360;
				this.pdfViewer.pagesRotation = newRotation;
			},
			requestPresentationMode: function requestPresentationMode() {
				if (!this.pdfPresentationMode) {
					return;
				}
				this.pdfPresentationMode.request();
			},
			bindEvents: function bindEvents() {
				var eventBus = this.eventBus,
					_boundEvents = this._boundEvents;
				_boundEvents.beforePrint = this.beforePrint.bind(this);
				_boundEvents.afterPrint = this.afterPrint.bind(this);
				eventBus.on('resize', webViewerResize);
				eventBus.on('hashchange', webViewerHashchange);
				eventBus.on('beforeprint', _boundEvents.beforePrint);
				eventBus.on('afterprint', _boundEvents.afterPrint);
				eventBus.on('pagerendered', webViewerPageRendered);
				eventBus.on('textlayerrendered', webViewerTextLayerRendered);
				eventBus.on('updateviewarea', webViewerUpdateViewarea);
				eventBus.on('pagechanging', webViewerPageChanging);
				eventBus.on('scalechanging', webViewerScaleChanging);
				eventBus.on('rotationchanging', webViewerRotationChanging);
				eventBus.on('sidebarviewchanged', webViewerSidebarViewChanged);
				eventBus.on('pagemode', webViewerPageMode);
				eventBus.on('namedaction', webViewerNamedAction);
				eventBus.on('presentationmodechanged', webViewerPresentationModeChanged);
				eventBus.on('presentationmode', webViewerPresentationMode);
				eventBus.on('openfile', webViewerOpenFile);
				eventBus.on('print', webViewerPrint);
				eventBus.on('download', webViewerDownload);
				eventBus.on('firstpage', webViewerFirstPage);
				eventBus.on('lastpage', webViewerLastPage);
				eventBus.on('nextpage', webViewerNextPage);
				eventBus.on('previouspage', webViewerPreviousPage);
				eventBus.on('zoomin', webViewerZoomIn);
				eventBus.on('zoomout', webViewerZoomOut);
				eventBus.on('pagenumberchanged', webViewerPageNumberChanged);
				eventBus.on('scalechanged', webViewerScaleChanged);
				eventBus.on('rotatecw', webViewerRotateCw);
				eventBus.on('rotateccw', webViewerRotateCcw);
				eventBus.on('documentproperties', webViewerDocumentProperties);
				eventBus.on('find', webViewerFind);
				eventBus.on('findfromurlhash', webViewerFindFromUrlHash);
				eventBus.on('fileinputchange', webViewerFileInputChange);
			},
			bindWindowEvents: function bindWindowEvents() {
				var eventBus = this.eventBus,
					_boundEvents = this._boundEvents;
				_boundEvents.windowResize = function() {
					eventBus.dispatch('resize');
				};
				_boundEvents.windowHashChange = function() {
					eventBus.dispatch('hashchange', {
						hash: document.location.hash.substring(1)
					});
				};
				_boundEvents.windowBeforePrint = function() {
					eventBus.dispatch('beforeprint');
				};
				_boundEvents.windowAfterPrint = function() {
					eventBus.dispatch('afterprint');
				};
				window.addEventListener('wheel', webViewerWheel);
				window.addEventListener('click', webViewerClick);
				window.addEventListener('keydown', webViewerKeyDown);
				window.addEventListener('resize', _boundEvents.windowResize);
				window.addEventListener('hashchange', _boundEvents.windowHashChange);
				window.addEventListener('beforeprint', _boundEvents.windowBeforePrint);
				window.addEventListener('afterprint', _boundEvents.windowAfterPrint);
			},
			unbindEvents: function unbindEvents() {
				var eventBus = this.eventBus,
					_boundEvents = this._boundEvents;
				eventBus.off('resize', webViewerResize);
				eventBus.off('hashchange', webViewerHashchange);
				eventBus.off('beforeprint', _boundEvents.beforePrint);
				eventBus.off('afterprint', _boundEvents.afterPrint);
				eventBus.off('pagerendered', webViewerPageRendered);
				eventBus.off('textlayerrendered', webViewerTextLayerRendered);
				eventBus.off('updateviewarea', webViewerUpdateViewarea);
				eventBus.off('pagechanging', webViewerPageChanging);
				eventBus.off('scalechanging', webViewerScaleChanging);
				eventBus.off('rotationchanging', webViewerRotationChanging);
				eventBus.off('sidebarviewchanged', webViewerSidebarViewChanged);
				eventBus.off('pagemode', webViewerPageMode);
				eventBus.off('namedaction', webViewerNamedAction);
				eventBus.off('presentationmodechanged', webViewerPresentationModeChanged);
				eventBus.off('presentationmode', webViewerPresentationMode);
				eventBus.off('openfile', webViewerOpenFile);
				eventBus.off('print', webViewerPrint);
				eventBus.off('download', webViewerDownload);
				eventBus.off('firstpage', webViewerFirstPage);
				eventBus.off('lastpage', webViewerLastPage);
				eventBus.off('nextpage', webViewerNextPage);
				eventBus.off('previouspage', webViewerPreviousPage);
				eventBus.off('zoomin', webViewerZoomIn);
				eventBus.off('zoomout', webViewerZoomOut);
				eventBus.off('pagenumberchanged', webViewerPageNumberChanged);
				eventBus.off('scalechanged', webViewerScaleChanged);
				eventBus.off('rotatecw', webViewerRotateCw);
				eventBus.off('rotateccw', webViewerRotateCcw);
				eventBus.off('documentproperties', webViewerDocumentProperties);
				eventBus.off('find', webViewerFind);
				eventBus.off('findfromurlhash', webViewerFindFromUrlHash);
				eventBus.off('fileinputchange', webViewerFileInputChange);
				_boundEvents.beforePrint = null;
				_boundEvents.afterPrint = null;
			},
			unbindWindowEvents: function unbindWindowEvents() {
				var _boundEvents = this._boundEvents;
				window.removeEventListener('wheel', webViewerWheel);
				window.removeEventListener('click', webViewerClick);
				window.removeEventListener('keydown', webViewerKeyDown);
				window.removeEventListener('resize', _boundEvents.windowResize);
				window.removeEventListener('hashchange', _boundEvents.windowHashChange);
				window.removeEventListener('beforeprint', _boundEvents.windowBeforePrint);
				window.removeEventListener('afterprint', _boundEvents.windowAfterPrint);
				_boundEvents.windowResize = null;
				_boundEvents.windowHashChange = null;
				_boundEvents.windowBeforePrint = null;
				_boundEvents.windowAfterPrint = null;
			}
		};
		var validateFileURL = void 0; {
			var HOSTED_VIEWER_ORIGINS = allowd_origins;
			validateFileURL = function validateFileURL(file) {
				if (file === undefined) {
					return;
				}
				try {
					var viewerOrigin = new URL(window.location.href).origin || 'null';
					if (HOSTED_VIEWER_ORIGINS.indexOf(viewerOrigin) >= 0) {
						return;
					}
					var fileOrigin = new URL(file, window.location.href).origin;
					if (fileOrigin !== viewerOrigin) {
						throw new Error('file origin does not match viewer\'s');
					}
				} catch (ex) {
					var message = ex && ex.message;
					PDFViewerApplication.l10n.get('loading_error', null,
						'An error occurred while loading the PDF.').then(function(loadingErrorMessage) {
						PDFViewerApplication.error(loadingErrorMessage, {
							message: message
						});
					});
					throw ex;
				}
			};
		}

		function loadAndEnablePDFBug(enabledTabs) {
			return new Promise(function(resolve, reject) {
				var appConfig = PDFViewerApplication.appConfig;
				var script = document.createElement('script');
				script.src = appConfig.debuggerScriptPath;
				script.onload = function() {
					PDFBug.enable(enabledTabs);
					PDFBug.init({
						PDFJS: _pdfjsLib.PDFJS,
						OPS: _pdfjsLib.OPS
					}, appConfig.mainContainer);
					resolve();
				};
				script.onerror = function() {
					reject(new Error('Cannot load debugger at ' + script.src));
				};
				(document.getElementsByTagName('head')[0] || document.body).appendChild(script);
			});
		}

		function webViewerInitialized() {
			var appConfig = PDFViewerApplication.appConfig;
			var file = void 0;
			var queryString = document.location.search.substring(1);
			var params = (0,
				_ui_utils.parseQueryString)(queryString);
			file = 'file' in params ? params.file : appConfig.defaultUrl;
			validateFileURL(file);
			var waitForBeforeOpening = [];
			var fileInput = document.createElement('input');
			fileInput.id = appConfig.openFileInputName;
			fileInput.className = 'fileInput';
			fileInput.setAttribute('type', 'file');
			fileInput.oncontextmenu = _ui_utils.noContextMenuHandler;
			document.body.appendChild(fileInput);
			if (!window.File || !window.FileReader || !window.FileList || !window.Blob) {
				appConfig.toolbar.openFile.setAttribute('hidden', 'true');
				appConfig.secondaryToolbar.openFileButton.setAttribute('hidden', 'true');
			} else {
				fileInput.value = null;
			}
			fileInput.addEventListener('change', function(evt) {
				var files = evt.target.files;
				if (!files || files.length === 0) {
					return;
				}
				PDFViewerApplication.eventBus.dispatch('fileinputchange', {
					fileInput: evt.target
				});
			});
			if (PDFViewerApplication.viewerPrefs['pdfBugEnabled']) {
				var hash = document.location.hash.substring(1);
				var hashParams = (0,
					_ui_utils.parseQueryString)(hash);
				if ('disableworker' in hashParams) {
					_pdfjsLib.PDFJS.disableWorker = hashParams['disableworker'] === 'true';
				}
				if ('disablerange' in hashParams) {
					_pdfjsLib.PDFJS.disableRange = hashParams['disablerange'] === 'true';
				}
				if ('disablestream' in hashParams) {
					_pdfjsLib.PDFJS.disableStream = hashParams['disablestream'] === 'true';
				}
				if ('disableautofetch' in hashParams) {
					_pdfjsLib.PDFJS.disableAutoFetch = hashParams['disableautofetch'] === 'true';
				}
				if ('disablefontface' in hashParams) {
					_pdfjsLib.PDFJS.disableFontFace = hashParams['disablefontface'] === 'true';
				}
				if ('disablehistory' in hashParams) {
					_pdfjsLib.PDFJS.disableHistory = hashParams['disablehistory'] === 'true';
				}
				if ('webgl' in hashParams) {
					_pdfjsLib.PDFJS.disableWebGL = hashParams['webgl'] !== 'true';
				}
				if ('useonlycsszoom' in hashParams) {
					_pdfjsLib.PDFJS.useOnlyCssZoom = hashParams['useonlycsszoom'] === 'true';
				}
				if ('verbosity' in hashParams) {
					_pdfjsLib.PDFJS.verbosity = hashParams['verbosity'] | 0;
				}
				if ('ignorecurrentpositiononzoom' in hashParams) {
					_pdfjsLib.PDFJS.ignoreCurrentPositionOnZoom = hashParams['ignorecurrentpositiononzoom'] ===
						'true';
				}
				if ('textlayer' in hashParams) {
					switch (hashParams['textlayer']) {
						case 'off':
							_pdfjsLib.PDFJS.disableTextLayer = true;
							break;
						case 'visible':
						case 'shadow':
						case 'hover':
							var viewer = appConfig.viewerContainer;
							viewer.classList.add('textLayer-' + hashParams['textlayer']);
							break;
					}
				}
				if ('pdfbug' in hashParams) {
					_pdfjsLib.PDFJS.pdfBug = true;
					var pdfBug = hashParams['pdfbug'];
					var enabled = pdfBug.split(',');
					waitForBeforeOpening.push(loadAndEnablePDFBug(enabled));
				}
			}
			if (!PDFViewerApplication.supportsPrinting) {
				appConfig.toolbar.print.classList.add('hidden');
				appConfig.secondaryToolbar.printButton.classList.add('hidden');
			}
			if (!PDFViewerApplication.supportsFullscreen) {
				appConfig.toolbar.presentationModeButton.classList.add('hidden');
				appConfig.secondaryToolbar.presentationModeButton.classList.add('hidden');
			}
			if (PDFViewerApplication.supportsIntegratedFind) {
				appConfig.toolbar.viewFind.classList.add('hidden');
			}
			appConfig.sidebar.mainContainer.addEventListener('transitionend', function(evt) {
				if (evt.target === this) {
					PDFViewerApplication.eventBus.dispatch('resize');
				}
			}, true);
			appConfig.sidebar.toggleButton.addEventListener('click', function() {
				PDFViewerApplication.pdfSidebar.toggle();
			});
			Promise.all(waitForBeforeOpening).then(function() {
				webViewerOpenFileViaURL(file);
			}).catch(function(reason) {
				PDFViewerApplication.l10n.get('loading_error', null, 'An error occurred while opening.')
					.then(function(msg) {
						PDFViewerApplication.error(msg, reason);
					});
			});
		}
		var webViewerOpenFileViaURL = void 0; {
			webViewerOpenFileViaURL = function webViewerOpenFileViaURL(file) {
				if (file && file.lastIndexOf('file:', 0) === 0) {
					PDFViewerApplication.setTitleUsingUrl(file);
					var xhr = new XMLHttpRequest();
					xhr.onload = function() {
						PDFViewerApplication.open(new Uint8Array(xhr.response));
					};
					try {
						xhr.open('GET', file);
						xhr.responseType = 'arraybuffer';
						xhr.send();
					} catch (ex) {
						PDFViewerApplication.l10n.get('loading_error', null,
							'An error occurred while loading the PDF.').then(function(msg) {
							PDFViewerApplication.error(msg, ex);
						});
					}
					return;
				}
				if (file) {
					PDFViewerApplication.open(file);
				}
			};
		}

		function webViewerPageRendered(evt) {
			var pageNumber = evt.pageNumber;
			var pageIndex = pageNumber - 1;
			var pageView = PDFViewerApplication.pdfViewer.getPageView(pageIndex);
			if (pageNumber === PDFViewerApplication.page) {
				PDFViewerApplication.toolbar.updateLoadingIndicatorState(false);
			}
			if (!pageView) {
				return;
			}
			if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
				var thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(pageIndex);
				thumbnailView.setImage(pageView);
			}
			if (_pdfjsLib.PDFJS.pdfBug && Stats.enabled && pageView.stats) {
				Stats.add(pageNumber, pageView.stats);
			}
			if (pageView.error) {
				PDFViewerApplication.l10n.get('rendering_error', null,
					'An error occurred while rendering the page.').then(function(msg) {
					PDFViewerApplication.error(msg, pageView.error);
				});
			}
		}

		function webViewerTextLayerRendered(evt) {}

		function webViewerPageMode(evt) {
			var mode = evt.mode,
				view = void 0;
			switch (mode) {
				case 'thumbs':
					view = _pdf_sidebar.SidebarView.THUMBS;
					break;
				case 'bookmarks':
				case 'outline':
					view = _pdf_sidebar.SidebarView.OUTLINE;
					break;
				case 'attachments':
					view = _pdf_sidebar.SidebarView.ATTACHMENTS;
					break;
				case 'none':
					view = _pdf_sidebar.SidebarView.NONE;
					break;
				default:
					console.error('Invalid "pagemode" hash parameter: ' + mode);
					return;
			}
			PDFViewerApplication.pdfSidebar.switchView(view, true);
		}

		function webViewerNamedAction(evt) {
			var action = evt.action;
			switch (action) {
				case 'GoToPage':
					PDFViewerApplication.appConfig.toolbar.pageNumber.select();
					break;
				case 'Find':
					if (!PDFViewerApplication.supportsIntegratedFind) {
						PDFViewerApplication.findBar.toggle();
					}
					break;
			}
		}

		function webViewerPresentationModeChanged(evt) {
			var active = evt.active,
				switchInProgress = evt.switchInProgress;
			PDFViewerApplication.pdfViewer.presentationModeState = switchInProgress ? _ui_utils
				.PresentationModeState.CHANGING : active ? _ui_utils.PresentationModeState.FULLSCREEN :
				_ui_utils.PresentationModeState.NORMAL;
		}

		function webViewerSidebarViewChanged(evt) {
			PDFViewerApplication.pdfRenderingQueue.isThumbnailViewEnabled = PDFViewerApplication.pdfSidebar
				.isThumbnailViewVisible;
			var store = PDFViewerApplication.store;
			if (store && PDFViewerApplication.isInitialViewSet) {
				store.set('sidebarView', evt.view).catch(function() {});
			}
		}

		function webViewerUpdateViewarea(evt) {
			var location = evt.location,
				store = PDFViewerApplication.store;
			if (store && PDFViewerApplication.isInitialViewSet) {
				store.setMultiple({
					'exists': true,
					'page': location.pageNumber,
					'zoom': location.scale,
					'scrollLeft': location.left,
					'scrollTop': location.top,
					'rotation': location.rotation
				}).catch(function() {});
			}
			var href = PDFViewerApplication.pdfLinkService.getAnchorUrl(location.pdfOpenParams);
			PDFViewerApplication.appConfig.toolbar.viewBookmark.href = href;
			PDFViewerApplication.appConfig.secondaryToolbar.viewBookmarkButton.href = href;
			var currentPage = PDFViewerApplication.pdfViewer.getPageView(PDFViewerApplication.page - 1);
			var loading = currentPage.renderingState !== _pdf_rendering_queue.RenderingStates.FINISHED;
			PDFViewerApplication.toolbar.updateLoadingIndicatorState(loading);
		}

		function webViewerResize() {
			var pdfDocument = PDFViewerApplication.pdfDocument,
				pdfViewer = PDFViewerApplication.pdfViewer;
			if (!pdfDocument) {
				return;
			}
			var currentScaleValue = pdfViewer.currentScaleValue;
			if (currentScaleValue === 'auto' || currentScaleValue === 'page-fit' || currentScaleValue ===
				'page-width') {
				pdfViewer.currentScaleValue = currentScaleValue;
			}
			pdfViewer.update();
		}

		function webViewerHashchange(evt) {
			var hash = evt.hash;
			if (!hash) {
				return;
			}
			if (!PDFViewerApplication.isInitialViewSet) {
				PDFViewerApplication.initialBookmark = hash;
			} else if (!PDFViewerApplication.pdfHistory.popStateInProgress) {
				PDFViewerApplication.pdfLinkService.setHash(hash);
			}
		}
		var webViewerFileInputChange = void 0; {
			webViewerFileInputChange = function webViewerFileInputChange(evt) {
				var file = evt.fileInput.files[0];
				if (!_pdfjsLib.PDFJS.disableCreateObjectURL && URL.createObjectURL) {
					PDFViewerApplication.open(URL.createObjectURL(file));
				} else {
					var fileReader = new FileReader();
					fileReader.onload = function webViewerChangeFileReaderOnload(evt) {
						var buffer = evt.target.result;
						PDFViewerApplication.open(new Uint8Array(buffer));
					};
					fileReader.readAsArrayBuffer(file);
				}
				PDFViewerApplication.setTitleUsingUrl(file.name);
				var appConfig = PDFViewerApplication.appConfig;
				appConfig.toolbar.viewBookmark.setAttribute('hidden', 'true');
				appConfig.secondaryToolbar.viewBookmarkButton.setAttribute('hidden', 'true');
				appConfig.toolbar.download.setAttribute('hidden', 'true');
				appConfig.secondaryToolbar.downloadButton.setAttribute('hidden', 'true');
			};
		}

		function webViewerPresentationMode() {
			PDFViewerApplication.requestPresentationMode();
		}

		function webViewerOpenFile() {
			var openFileInputName = PDFViewerApplication.appConfig.openFileInputName;
			document.getElementById(openFileInputName).click();
		}

		function webViewerPrint() {
			window.print();
		}

		function webViewerDownload() {
			PDFViewerApplication.download();
		}

		function webViewerFirstPage() {
			if (PDFViewerApplication.pdfDocument) {
				PDFViewerApplication.page = 1;
			}
		}

		function webViewerLastPage() {
			if (PDFViewerApplication.pdfDocument) {
				PDFViewerApplication.page = PDFViewerApplication.pagesCount;
			}
		}

		function webViewerNextPage() {
			PDFViewerApplication.page++;
		}

		function webViewerPreviousPage() {
			PDFViewerApplication.page--;
		}

		function webViewerZoomIn() {
			PDFViewerApplication.zoomIn();
		}

		function webViewerZoomOut() {
			PDFViewerApplication.zoomOut();
		}

		function webViewerPageNumberChanged(evt) {
			var pdfViewer = PDFViewerApplication.pdfViewer;
			pdfViewer.currentPageLabel = evt.value;
			if (evt.value !== pdfViewer.currentPageNumber.toString() && evt.value !== pdfViewer
				.currentPageLabel) {
				PDFViewerApplication.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer
					.currentPageLabel);
			}
		}

		function webViewerScaleChanged(evt) {
			PDFViewerApplication.pdfViewer.currentScaleValue = evt.value;
		}

		function webViewerRotateCw() {
			PDFViewerApplication.rotatePages(90);
		}

		function webViewerRotateCcw() {
			PDFViewerApplication.rotatePages(-90);
		}

		function webViewerDocumentProperties() {
			PDFViewerApplication.pdfDocumentProperties.open();
		}

		function webViewerFind(evt) {
			PDFViewerApplication.findController.executeCommand('find' + evt.type, {
				query: evt.query,
				phraseSearch: evt.phraseSearch,
				caseSensitive: evt.caseSensitive,
				highlightAll: evt.highlightAll,
				findPrevious: evt.findPrevious
			});
		}

		function webViewerFindFromUrlHash(evt) {
			PDFViewerApplication.findController.executeCommand('find', {
				query: evt.query,
				phraseSearch: evt.phraseSearch,
				caseSensitive: false,
				highlightAll: true,
				findPrevious: false
			});
		}

		function webViewerScaleChanging(evt) {
			PDFViewerApplication.toolbar.setPageScale(evt.presetValue, evt.scale);
			PDFViewerApplication.pdfViewer.update();
		}

		function webViewerRotationChanging(evt) {
			PDFViewerApplication.pdfThumbnailViewer.pagesRotation = evt.pagesRotation;
			PDFViewerApplication.forceRendering();
			PDFViewerApplication.pdfViewer.currentPageNumber = evt.pageNumber;
		}

		function webViewerPageChanging(evt) {
			var page = evt.pageNumber;
			PDFViewerApplication.toolbar.setPageNumber(page, evt.pageLabel || null);
			PDFViewerApplication.secondaryToolbar.setPageNumber(page);
			if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
				PDFViewerApplication.pdfThumbnailViewer.scrollThumbnailIntoView(page);
			}
			if (_pdfjsLib.PDFJS.pdfBug && Stats.enabled) {
				var pageView = PDFViewerApplication.pdfViewer.getPageView(page - 1);
				if (pageView.stats) {
					Stats.add(page, pageView.stats);
				}
			}
		}
		var zoomDisabled = false,
			zoomDisabledTimeout = void 0;

		function webViewerWheel(evt) {
			var pdfViewer = PDFViewerApplication.pdfViewer;
			if (pdfViewer.isInPresentationMode) {
				return;
			}
			if (evt.ctrlKey || evt.metaKey) {
				var support = PDFViewerApplication.supportedMouseWheelZoomModifierKeys;
				if (evt.ctrlKey && !support.ctrlKey || evt.metaKey && !support.metaKey) {
					return;
				}
				evt.preventDefault();
				if (zoomDisabled) {
					return;
				}
				var previousScale = pdfViewer.currentScale;
				var delta = (0,
					_ui_utils.normalizeWheelEventDelta)(evt);
				var MOUSE_WHEEL_DELTA_PER_PAGE_SCALE = 3.0;
				var ticks = delta * MOUSE_WHEEL_DELTA_PER_PAGE_SCALE;
				if (ticks < 0) {
					PDFViewerApplication.zoomOut(-ticks);
				} else {
					PDFViewerApplication.zoomIn(ticks);
				}
				var currentScale = pdfViewer.currentScale;
				if (previousScale !== currentScale) {
					var scaleCorrectionFactor = currentScale / previousScale - 1;
					var rect = pdfViewer.container.getBoundingClientRect();
					var dx = evt.clientX - rect.left;
					var dy = evt.clientY - rect.top;
					pdfViewer.container.scrollLeft += dx * scaleCorrectionFactor;
					pdfViewer.container.scrollTop += dy * scaleCorrectionFactor;
				}
			} else {
				zoomDisabled = true;
				clearTimeout(zoomDisabledTimeout);
				zoomDisabledTimeout = setTimeout(function() {
					zoomDisabled = false;
				}, 1000);
			}
		}

		function webViewerClick(evt) {
			if (!PDFViewerApplication.secondaryToolbar.isOpen) {
				return;
			}
			var appConfig = PDFViewerApplication.appConfig;
			if (PDFViewerApplication.pdfViewer.containsElement(evt.target) || appConfig.toolbar.container
				.contains(evt.target) && evt.target !== appConfig.secondaryToolbar.toggleButton) {
				PDFViewerApplication.secondaryToolbar.close();
			}
		}

		function webViewerKeyDown(evt) {
			if (PDFViewerApplication.overlayManager.active) {
				return;
			}
			var handled = false,
				ensureViewerFocused = false;
			var cmd = (evt.ctrlKey ? 1 : 0) | (evt.altKey ? 2 : 0) | (evt.shiftKey ? 4 : 0) | (evt.metaKey ? 8 :
				0);
			var pdfViewer = PDFViewerApplication.pdfViewer;
			var isViewerInPresentationMode = pdfViewer && pdfViewer.isInPresentationMode;
			if (cmd === 1 || cmd === 8 || cmd === 5 || cmd === 12) {
				switch (evt.keyCode) {
					case 70:
						if (!PDFViewerApplication.supportsIntegratedFind) {
							PDFViewerApplication.findBar.open();
							handled = true;
						}
						break;
					case 71:
						if (!PDFViewerApplication.supportsIntegratedFind) {
							var findState = PDFViewerApplication.findController.state;
							if (findState) {
								PDFViewerApplication.findController.executeCommand('findagain', {
									query: findState.query,
									phraseSearch: findState.phraseSearch,
									caseSensitive: findState.caseSensitive,
									highlightAll: findState.highlightAll,
									findPrevious: cmd === 5 || cmd === 12
								});
							}
							handled = true;
						}
						break;
					case 61:
					case 107:
					case 187:
					case 171:
						if (!isViewerInPresentationMode) {
							PDFViewerApplication.zoomIn();
						}
						handled = true;
						break;
					case 173:
					case 109:
					case 189:
						if (!isViewerInPresentationMode) {
							PDFViewerApplication.zoomOut();
						}
						handled = true;
						break;
					case 48:
					case 96:
						if (!isViewerInPresentationMode) {
							setTimeout(function() {
								pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
							});
							handled = false;
						}
						break;
					case 38:
						if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
							PDFViewerApplication.page = 1;
							handled = true;
							ensureViewerFocused = true;
						}
						break;
					case 40:
						if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication
							.pagesCount) {
							PDFViewerApplication.page = PDFViewerApplication.pagesCount;
							handled = true;
							ensureViewerFocused = true;
						}
						break;
				}
			}
			if (cmd === 1 || cmd === 8) {
				switch (evt.keyCode) {
					case 83:
						PDFViewerApplication.download();
						handled = true;
						break;
				}
			}
			if (cmd === 3 || cmd === 10) {
				switch (evt.keyCode) {
					case 80:
						PDFViewerApplication.requestPresentationMode();
						handled = true;
						break;
					case 71:
						PDFViewerApplication.appConfig.toolbar.pageNumber.select();
						handled = true;
						break;
				}
			}
			if (handled) {
				if (ensureViewerFocused && !isViewerInPresentationMode) {
					pdfViewer.focus();
				}
				evt.preventDefault();
				return;
			}
			var curElement = document.activeElement || document.querySelector(':focus');
			var curElementTagName = curElement && curElement.tagName.toUpperCase();
			if (curElementTagName === 'INPUT' || curElementTagName === 'TEXTAREA' || curElementTagName ===
				'SELECT') {
				if (evt.keyCode !== 27) {
					return;
				}
			}
			if (cmd === 0) {
				switch (evt.keyCode) {
					case 38:
					case 33:
					case 8:
						if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== 'page-fit') {
							break;
						}
					case 37:
						if (pdfViewer.isHorizontalScrollbarEnabled) {
							break;
						}
					case 75:
					case 80:
						if (PDFViewerApplication.page > 1) {
							PDFViewerApplication.page--;
						}
						handled = true;
						break;
					case 27:
						if (PDFViewerApplication.secondaryToolbar.isOpen) {
							PDFViewerApplication.secondaryToolbar.close();
							handled = true;
						}
						if (!PDFViewerApplication.supportsIntegratedFind && PDFViewerApplication.findBar
							.opened) {
							PDFViewerApplication.findBar.close();
							handled = true;
						}
						break;
					case 40:
					case 34:
					case 32:
						if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== 'page-fit') {
							break;
						}
					case 39:
						if (pdfViewer.isHorizontalScrollbarEnabled) {
							break;
						}
					case 74:
					case 78:
						if (PDFViewerApplication.page < PDFViewerApplication.pagesCount) {
							PDFViewerApplication.page++;
						}
						handled = true;
						break;
					case 36:
						if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
							PDFViewerApplication.page = 1;
							handled = true;
							ensureViewerFocused = true;
						}
						break;
					case 35:
						if (isViewerInPresentationMode || PDFViewerApplication.page < PDFViewerApplication
							.pagesCount) {
							PDFViewerApplication.page = PDFViewerApplication.pagesCount;
							handled = true;
							ensureViewerFocused = true;
						}
						break;
					case 83:
						PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools.CursorTool.SELECT);
						break;
					case 72:
						PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools.CursorTool.HAND);
						break;
					case 82:
						PDFViewerApplication.rotatePages(90);
						break;
				}
			}
			if (cmd === 4) {
				switch (evt.keyCode) {
					case 32:
						if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !== 'page-fit') {
							break;
						}
						if (PDFViewerApplication.page > 1) {
							PDFViewerApplication.page--;
						}
						handled = true;
						break;
					case 82:
						PDFViewerApplication.rotatePages(-90);
						break;
				}
			}
			if (!handled && !isViewerInPresentationMode) {
				if (evt.keyCode >= 33 && evt.keyCode <= 40 || evt.keyCode === 32 && curElementTagName !==
					'BUTTON') {
					ensureViewerFocused = true;
				}
			}
			if (ensureViewerFocused && !pdfViewer.containsElement(curElement)) {
				pdfViewer.focus();
			}
			if (handled) {
				evt.preventDefault();
			}
		}

		function apiPageModeToSidebarView(mode) {
			switch (mode) {
				case 'UseNone':
					return _pdf_sidebar.SidebarView.NONE;
				case 'UseThumbs':
					return _pdf_sidebar.SidebarView.THUMBS;
				case 'UseOutlines':
					return _pdf_sidebar.SidebarView.OUTLINE;
				case 'UseAttachments':
					return _pdf_sidebar.SidebarView.ATTACHMENTS;
				case 'UseOC':
			}
			return _pdf_sidebar.SidebarView.NONE;
		}
		var PDFPrintServiceFactory = {
			instance: {
				supportsPrinting: false,
				createPrintService: function createPrintService() {
					throw new Error('Not implemented: createPrintService');
				}
			}
		};
		exports.PDFViewerApplication = PDFViewerApplication;
		exports.DefaultExternalServices = DefaultExternalServices;
		exports.PDFPrintServiceFactory = PDFPrintServiceFactory;
	}), /* 5 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.SimpleLinkService = exports.PDFLinkService = undefined;
		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
				return typeof obj;
			} :
			function(obj) {
				return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol
					.prototype ? "symbol" : typeof obj;
			};
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _dom_events = __webpack_require__(2);
		var _ui_utils = __webpack_require__(0);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var PDFLinkService = function() {
			function PDFLinkService() {
				var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
					eventBus = _ref.eventBus;
				_classCallCheck(this, PDFLinkService);
				this.eventBus = eventBus || (0,
					_dom_events.getGlobalEventBus)();
				this.baseUrl = null;
				this.pdfDocument = null;
				this.pdfViewer = null;
				this.pdfHistory = null;
				this._pagesRefCache = null;
			}
			_createClass(PDFLinkService, [{
				key: 'setDocument',
				value: function setDocument(pdfDocument, baseUrl) {
					this.baseUrl = baseUrl;
					this.pdfDocument = pdfDocument;
					this._pagesRefCache = Object.create(null);
				}
			}, {
				key: 'setViewer',
				value: function setViewer(pdfViewer) {
					this.pdfViewer = pdfViewer;
				}
			}, {
				key: 'setHistory',
				value: function setHistory(pdfHistory) {
					this.pdfHistory = pdfHistory;
				}
			}, {
				key: 'navigateTo',
				value: function navigateTo(dest) {
					var _this = this;
					var goToDestination = function goToDestination(_ref2) {
						var namedDest = _ref2.namedDest,
							explicitDest = _ref2.explicitDest;
						var destRef = explicitDest[0],
							pageNumber = void 0;
						if (destRef instanceof Object) {
							pageNumber = _this._cachedPageNumber(destRef);
							if (pageNumber === null) {
								_this.pdfDocument.getPageIndex(destRef).then(function(
									pageIndex) {
									_this.cachePageRef(pageIndex + 1, destRef);
									goToDestination({
										namedDest: namedDest,
										explicitDest: explicitDest
									});
								}).catch(function() {
									console.error(
										'PDFLinkService.navigateTo: "' +
										destRef + '" is not ' + (
											'a valid page reference, for dest="' +
											dest + '".'));
								});
								return;
							}
						} else if (Number.isInteger(destRef)) {
							pageNumber = destRef + 1;
						} else {
							console.error('PDFLinkService.navigateTo: "' + destRef +
								'" is not ' + (
									'a valid destination reference, for dest="' +
									dest + '".'));
							return;
						}
						if (!pageNumber || pageNumber < 1 || pageNumber > _this
							.pagesCount) {
							console.error('PDFLinkService.navigateTo: "' + pageNumber +
								'" is not ' + ('a valid page number, for dest="' +
									dest + '".'));
							return;
						}
						if (_this.pdfHistory) {
							_this.pdfHistory.pushCurrentPosition();
							_this.pdfHistory.push({
								namedDest: namedDest,
								explicitDest: explicitDest,
								pageNumber: pageNumber
							});
						}
						_this.pdfViewer.scrollPageIntoView({
							pageNumber: pageNumber,
							destArray: explicitDest
						});
					};
					new Promise(function(resolve, reject) {
						if (typeof dest === 'string') {
							_this.pdfDocument.getDestination(dest).then(function(
								destArray) {
								resolve({
									namedDest: dest,
									explicitDest: destArray
								});
							});
							return;
						}
						resolve({
							namedDest: '',
							explicitDest: dest
						});
					}).then(function(data) {
						if (!(data.explicitDest instanceof Array)) {
							console.error('PDFLinkService.navigateTo: "' + data
								.explicitDest + '" is' + (
									' not a valid destination array, for dest="' +
									dest + '".'));
							return;
						}
						goToDestination(data);
					});
				}
			}, {
				key: 'getDestinationHash',
				value: function getDestinationHash(dest) {
					if (typeof dest === 'string') {
						return this.getAnchorUrl('#' + escape(dest));
					}
					if (dest instanceof Array) {
						var str = JSON.stringify(dest);
						return this.getAnchorUrl('#' + escape(str));
					}
					return this.getAnchorUrl('');
				}
			}, {
				key: 'getAnchorUrl',
				value: function getAnchorUrl(anchor) {
					return (this.baseUrl || '') + anchor;
				}
			}, {
				key: 'setHash',
				value: function setHash(hash) {
					var pageNumber = void 0,
						dest = void 0;
					if (hash.indexOf('=') >= 0) {
						var params = (0,
							_ui_utils.parseQueryString)(hash);
						if ('search' in params) {
							this.eventBus.dispatch('findfromurlhash', {
								source: this,
								query: params['search'].replace(/"/g, ''),
								phraseSearch: params['phrase'] === 'true'
							});
						}
						if ('nameddest' in params) {
							this.navigateTo(params.nameddest);
							return;
						}
						if ('page' in params) {
							pageNumber = params.page | 0 || 1;
						}
						if ('zoom' in params) {
							var zoomArgs = params.zoom.split(',');
							var zoomArg = zoomArgs[0];
							var zoomArgNumber = parseFloat(zoomArg);
							if (zoomArg.indexOf('Fit') === -1) {
								dest = [null, {
										name: 'XYZ'
									}, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,
									zoomArgs.length > 2 ? zoomArgs[2] | 0 : null,
									zoomArgNumber ? zoomArgNumber / 100 : zoomArg
								];
							} else {
								if (zoomArg === 'Fit' || zoomArg === 'FitB') {
									dest = [null, {
										name: zoomArg
									}];
								} else if (zoomArg === 'FitH' || zoomArg === 'FitBH' ||
									zoomArg === 'FitV' || zoomArg === 'FitBV') {
									dest = [null, {
										name: zoomArg
									}, zoomArgs.length > 1 ? zoomArgs[1] | 0 : null];
								} else if (zoomArg === 'FitR') {
									if (zoomArgs.length !== 5) {
										console.error(
											'PDFLinkService.setHash: Not enough parameters for "FitR".'
											);
									} else {
										dest = [null, {
												name: zoomArg
											}, zoomArgs[1] | 0, zoomArgs[2] | 0,
											zoomArgs[3] | 0, zoomArgs[4] | 0
										];
									}
								} else {
									console.error('PDFLinkService.setHash: "' + zoomArg +
										'" is not ' + 'a valid zoom value.');
								}
							}
						}
						if (dest) {
							this.pdfViewer.scrollPageIntoView({
								pageNumber: pageNumber || this.page,
								destArray: dest,
								allowNegativeOffset: true
							});
						} else if (pageNumber) {
							this.page = pageNumber;
						}
						if ('pagemode' in params) {
							this.eventBus.dispatch('pagemode', {
								source: this,
								mode: params.pagemode
							});
						}
					} else {
						if (/^\d+$/.test(hash) && hash <= this.pagesCount) {
							console.warn(
								'PDFLinkService_setHash: specifying a page number ' +
								'directly after the hash symbol (#) is deprecated, ' + (
									'please use the "#page=' + hash + '" form instead.')
								);
							this.page = hash | 0;
						}
						dest = unescape(hash);
						try {
							dest = JSON.parse(dest);
							if (!(dest instanceof Array)) {
								dest = dest.toString();
							}
						} catch (ex) {}
						if (typeof dest === 'string' || isValidExplicitDestination(dest)) {
							this.navigateTo(dest);
							return;
						}
						console.error('PDFLinkService.setHash: "' + unescape(hash) +
							'" is not ' + 'a valid destination.');
					}
				}
			}, {
				key: 'executeNamedAction',
				value: function executeNamedAction(action) {
					switch (action) {
						case 'GoBack':
							if (this.pdfHistory) {
								this.pdfHistory.back();
							}
							break;
						case 'GoForward':
							if (this.pdfHistory) {
								this.pdfHistory.forward();
							}
							break;
						case 'NextPage':
							if (this.page < this.pagesCount) {
								this.page++;
							}
							break;
						case 'PrevPage':
							if (this.page > 1) {
								this.page--;
							}
							break;
						case 'LastPage':
							this.page = this.pagesCount;
							break;
						case 'FirstPage':
							this.page = 1;
							break;
						default:
							break;
					}
					this.eventBus.dispatch('namedaction', {
						source: this,
						action: action
					});
				}
			}, {
				key: 'onFileAttachmentAnnotation',
				value: function onFileAttachmentAnnotation(_ref3) {
					var id = _ref3.id,
						filename = _ref3.filename,
						content = _ref3.content;
					this.eventBus.dispatch('fileattachmentannotation', {
						source: this,
						id: id,
						filename: filename,
						content: content
					});
				}
			}, {
				key: 'cachePageRef',
				value: function cachePageRef(pageNum, pageRef) {
					var refStr = pageRef.num + ' ' + pageRef.gen + ' R';
					this._pagesRefCache[refStr] = pageNum;
				}
			}, {
				key: '_cachedPageNumber',
				value: function _cachedPageNumber(pageRef) {
					var refStr = pageRef.num + ' ' + pageRef.gen + ' R';
					return this._pagesRefCache && this._pagesRefCache[refStr] || null;
				}
			}, {
				key: 'pagesCount',
				get: function get() {
					return this.pdfDocument ? this.pdfDocument.numPages : 0;
				}
			}, {
				key: 'page',
				get: function get() {
					return this.pdfViewer.currentPageNumber;
				},
				set: function set(value) {
					this.pdfViewer.currentPageNumber = value;
				}
			}, {
				key: 'rotation',
				get: function get() {
					return this.pdfViewer.pagesRotation;
				},
				set: function set(value) {
					this.pdfViewer.pagesRotation = value;
				}
			}]);
			return PDFLinkService;
		}();

		function isValidExplicitDestination(dest) {
			if (!(dest instanceof Array)) {
				return false;
			}
			var destLength = dest.length,
				allowNull = true;
			if (destLength < 2) {
				return false;
			}
			var page = dest[0];
			if (!((typeof page === 'undefined' ? 'undefined' : _typeof(page)) === 'object' && Number.isInteger(
					page.num) && Number.isInteger(page.gen)) && !(Number.isInteger(page) && page >= 0)) {
				return false;
			}
			var zoom = dest[1];
			if (!((typeof zoom === 'undefined' ? 'undefined' : _typeof(zoom)) === 'object' && typeof zoom
					.name === 'string')) {
				return false;
			}
			switch (zoom.name) {
				case 'XYZ':
					if (destLength !== 5) {
						return false;
					}
					break;
				case 'Fit':
				case 'FitB':
					return destLength === 2;
				case 'FitH':
				case 'FitBH':
				case 'FitV':
				case 'FitBV':
					if (destLength !== 3) {
						return false;
					}
					break;
				case 'FitR':
					if (destLength !== 6) {
						return false;
					}
					allowNull = false;
					break;
				default:
					return false;
			}
			for (var i = 2; i < destLength; i++) {
				var param = dest[i];
				if (!(typeof param === 'number' || allowNull && param === null)) {
					return false;
				}
			}
			return true;
		}
		var SimpleLinkService = function() {
			function SimpleLinkService() {
				_classCallCheck(this, SimpleLinkService);
			}
			_createClass(SimpleLinkService, [{
				key: 'navigateTo',
				value: function navigateTo(dest) {}
			}, {
				key: 'getDestinationHash',
				value: function getDestinationHash(dest) {
					return '#';
				}
			}, {
				key: 'getAnchorUrl',
				value: function getAnchorUrl(hash) {
					return '#';
				}
			}, {
				key: 'setHash',
				value: function setHash(hash) {}
			}, {
				key: 'executeNamedAction',
				value: function executeNamedAction(action) {}
			}, {
				key: 'onFileAttachmentAnnotation',
				value: function onFileAttachmentAnnotation(_ref4) {
					var id = _ref4.id,
						filename = _ref4.filename,
						content = _ref4.content;
				}
			}, {
				key: 'cachePageRef',
				value: function cachePageRef(pageNum, pageRef) {}
			}, {
				key: 'page',
				get: function get() {
					return 0;
				},
				set: function set(value) {}
			}, {
				key: 'rotation',
				get: function get() {
					return 0;
				},
				set: function set(value) {}
			}]);
			return SimpleLinkService;
		}();
		exports.PDFLinkService = PDFLinkService;
		exports.SimpleLinkService = SimpleLinkService;
	}), /* 6 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFCursorTools = exports.CursorTool = undefined;
		var _slicedToArray = function() {
			function sliceIterator(arr, i) {
				var _arr = [];
				var _n = true;
				var _d = false;
				var _e = undefined;
				try {
					for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
						_arr.push(_s.value);
						if (i && _arr.length === i)
							break;
					}
				} catch (err) {
					_d = true;
					_e = err;
				} finally {
					try {
						if (!_n && _i["return"])
							_i["return"]();
					} finally {
						if (_d)
							throw _e;
					}
				}
				return _arr;
			}
			return function(arr, i) {
				if (Array.isArray(arr)) {
					return arr;
				} else if (Symbol.iterator in Object(arr)) {
					return sliceIterator(arr, i);
				} else {
					throw new TypeError("Invalid attempt to destructure non-iterable instance");
				}
			};
		}();
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _grab_to_pan = __webpack_require__(9);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var CursorTool = {
			SELECT: 0,
			HAND: 1,
			ZOOM: 2
		};
		var PDFCursorTools = function() {
			function PDFCursorTools(_ref) {
				var _this = this;
				var container = _ref.container,
					eventBus = _ref.eventBus,
					preferences = _ref.preferences;
				_classCallCheck(this, PDFCursorTools);
				this.container = container;
				this.eventBus = eventBus;
				this.active = CursorTool.SELECT;
				this.activeBeforePresentationMode = null;
				this.handTool = new _grab_to_pan.GrabToPan({
					element: this.container
				});
				this._addEventListeners();
				Promise.all([preferences.get('cursorToolOnLoad'), preferences.get('enableHandToolOnLoad')])
					.then(function(_ref2) {
						var _ref3 = _slicedToArray(_ref2, 2),
							cursorToolPref = _ref3[0],
							handToolPref = _ref3[1];
						if (handToolPref === true) {
							preferences.set('enableHandToolOnLoad', false);
							if (cursorToolPref === CursorTool.SELECT) {
								cursorToolPref = CursorTool.HAND;
								preferences.set('cursorToolOnLoad', cursorToolPref).catch(
							function() {});
							}
						}
						_this.switchTool(cursorToolPref);
					}).catch(function() {});
			}
			_createClass(PDFCursorTools, [{
				key: 'switchTool',
				value: function switchTool(tool) {
					var _this2 = this;
					if (this.activeBeforePresentationMode !== null) {
						return;
					}
					if (tool === this.active) {
						return;
					}
					var disableActiveTool = function disableActiveTool() {
						switch (_this2.active) {
							case CursorTool.SELECT:
								break;
							case CursorTool.HAND:
								_this2.handTool.deactivate();
								break;
							case CursorTool.ZOOM:
						}
					};
					switch (tool) {
						case CursorTool.SELECT:
							disableActiveTool();
							break;
						case CursorTool.HAND:
							disableActiveTool();
							this.handTool.activate();
							break;
						case CursorTool.ZOOM:
						default:
							console.error('switchTool: "' + tool +
								'" is an unsupported value.');
							return;
					}
					this.active = tool;
					this._dispatchEvent();
				}
			}, {
				key: '_dispatchEvent',
				value: function _dispatchEvent() {
					this.eventBus.dispatch('cursortoolchanged', {
						source: this,
						tool: this.active
					});
				}
			}, {
				key: '_addEventListeners',
				value: function _addEventListeners() {
					var _this3 = this;
					this.eventBus.on('switchcursortool', function(evt) {
						_this3.switchTool(evt.tool);
					});
					this.eventBus.on('presentationmodechanged', function(evt) {
						if (evt.switchInProgress) {
							return;
						}
						var previouslyActive = void 0;
						if (evt.active) {
							previouslyActive = _this3.active;
							_this3.switchTool(CursorTool.SELECT);
							_this3.activeBeforePresentationMode = previouslyActive;
						} else {
							previouslyActive = _this3.activeBeforePresentationMode;
							_this3.activeBeforePresentationMode = null;
							_this3.switchTool(previouslyActive);
						}
					});
				}
			}, {
				key: 'activeTool',
				get: function get() {
					return this.active;
				}
			}]);
			return PDFCursorTools;
		}();
		exports.CursorTool = CursorTool;
		exports.PDFCursorTools = PDFCursorTools;
	}), /* 7 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFFindController = exports.FindState = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdfjsLib = __webpack_require__(1);
		var _ui_utils = __webpack_require__(0);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var FindState = {
			FOUND: 0,
			NOT_FOUND: 1,
			WRAPPED: 2,
			PENDING: 3
		};
		var FIND_SCROLL_OFFSET_TOP = -50;
		var FIND_SCROLL_OFFSET_LEFT = -400;
		var FIND_TIMEOUT = 250;
		var CHARACTERS_TO_NORMALIZE = {
			'\u2018': '\'',
			'\u2019': '\'',
			'\u201A': '\'',
			'\u201B': '\'',
			'\u201C': '"',
			'\u201D': '"',
			'\u201E': '"',
			'\u201F': '"',
			'\xBC': '1/4',
			'\xBD': '1/2',
			'\xBE': '3/4'
		};
		var PDFFindController = function() {
			function PDFFindController(_ref) {
				var pdfViewer = _ref.pdfViewer;
				_classCallCheck(this, PDFFindController);
				this.pdfViewer = pdfViewer;
				this.onUpdateResultsCount = null;
				this.onUpdateState = null;
				this.reset();
				var replace = Object.keys(CHARACTERS_TO_NORMALIZE).join('');
				this.normalizationRegex = new RegExp('[' + replace + ']', 'g');
			}
			_createClass(PDFFindController, [{
				key: 'reset',
				value: function reset() {
					var _this = this;
					this.startedTextExtraction = false;
					this.extractTextPromises = [];
					this.pendingFindMatches = Object.create(null);
					this.active = false;
					this.pageContents = [];
					this.pageMatches = [];
					this.pageMatchesLength = null;
					this.matchCount = 0;
					this.selected = {
						pageIdx: -1,
						matchIdx: -1
					};
					this.offset = {
						pageIdx: null,
						matchIdx: null
					};
					this.pagesToSearch = null;
					this.resumePageIdx = null;
					this.state = null;
					this.dirtyMatch = false;
					this.findTimeout = null;
					this._firstPagePromise = new Promise(function(resolve) {
						_this.resolveFirstPage = resolve;
					});
				}
			}, {
				key: 'normalize',
				value: function normalize(text) {
					return text.replace(this.normalizationRegex, function(ch) {
						return CHARACTERS_TO_NORMALIZE[ch];
					});
				}
			}, {
				key: '_prepareMatches',
				value: function _prepareMatches(matchesWithLength, matches, matchesLength) {
					function isSubTerm(matchesWithLength, currentIndex) {
						var currentElem = matchesWithLength[currentIndex];
						var nextElem = matchesWithLength[currentIndex + 1];
						if (currentIndex < matchesWithLength.length - 1 && currentElem
							.match === nextElem.match) {
							currentElem.skipped = true;
							return true;
						}
						for (var i = currentIndex - 1; i >= 0; i--) {
							var prevElem = matchesWithLength[i];
							if (prevElem.skipped) {
								continue;
							}
							if (prevElem.match + prevElem.matchLength < currentElem.match) {
								break;
							}
							if (prevElem.match + prevElem.matchLength >= currentElem.match +
								currentElem.matchLength) {
								currentElem.skipped = true;
								return true;
							}
						}
						return false;
					}
					matchesWithLength.sort(function(a, b) {
						return a.match === b.match ? a.matchLength - b.matchLength :
							a.match - b.match;
					});
					for (var i = 0, len = matchesWithLength.length; i < len; i++) {
						if (isSubTerm(matchesWithLength, i)) {
							continue;
						}
						matches.push(matchesWithLength[i].match);
						matchesLength.push(matchesWithLength[i].matchLength);
					}
				}
			}, {
				key: 'calcFindPhraseMatch',
				value: function calcFindPhraseMatch(query, pageIndex, pageContent) {
					var matches = [];
					var queryLen = query.length;
					var matchIdx = -queryLen;
					while (true) {
						matchIdx = pageContent.indexOf(query, matchIdx + queryLen);
						if (matchIdx === -1) {
							break;
						}
						matches.push(matchIdx);
					}
					this.pageMatches[pageIndex] = matches;
				}
			}, {
				key: 'calcFindWordMatch',
				value: function calcFindWordMatch(query, pageIndex, pageContent) {
					var matchesWithLength = [];
					var queryArray = query.match(/\S+/g);
					for (var i = 0, len = queryArray.length; i < len; i++) {
						var subquery = queryArray[i];
						var subqueryLen = subquery.length;
						var matchIdx = -subqueryLen;
						while (true) {
							matchIdx = pageContent.indexOf(subquery, matchIdx +
							subqueryLen);
							if (matchIdx === -1) {
								break;
							}
							matchesWithLength.push({
								match: matchIdx,
								matchLength: subqueryLen,
								skipped: false
							});
						}
					}
					if (!this.pageMatchesLength) {
						this.pageMatchesLength = [];
					}
					this.pageMatchesLength[pageIndex] = [];
					this.pageMatches[pageIndex] = [];
					this._prepareMatches(matchesWithLength, this.pageMatches[pageIndex],
						this.pageMatchesLength[pageIndex]);
				}
			}, {
				key: 'calcFindMatch',
				value: function calcFindMatch(pageIndex) {
					var pageContent = this.normalize(this.pageContents[pageIndex]);
					var query = this.normalize(this.state.query);
					var caseSensitive = this.state.caseSensitive;
					var phraseSearch = this.state.phraseSearch;
					var queryLen = query.length;
					if (queryLen === 0) {
						return;
					}
					if (!caseSensitive) {
						pageContent = pageContent.toLowerCase();
						query = query.toLowerCase();
					}
					if (phraseSearch) {
						this.calcFindPhraseMatch(query, pageIndex, pageContent);
					} else {
						this.calcFindWordMatch(query, pageIndex, pageContent);
					}
					this.updatePage(pageIndex);
					if (this.resumePageIdx === pageIndex) {
						this.resumePageIdx = null;
						this.nextPageMatch();
					}
					if (this.pageMatches[pageIndex].length > 0) {
						this.matchCount += this.pageMatches[pageIndex].length;
						this.updateUIResultsCount();
					}
				}
			}, {
				key: 'extractText',
				value: function extractText() {
					var _this2 = this;
					if (this.startedTextExtraction) {
						return;
					}
					this.startedTextExtraction = true;
					this.pageContents.length = 0;
					var promise = Promise.resolve();
					var _loop = function _loop(i, ii) {
						var extractTextCapability = (0,
							_pdfjsLib.createPromiseCapability)();
						_this2.extractTextPromises[i] = extractTextCapability.promise;
						promise = promise.then(function() {
							return _this2.pdfViewer.getPageTextContent(i).then(
								function(textContent) {
									var textItems = textContent.items;
									var strBuf = [];
									for (var j = 0, jj = textItems
										.length; j < jj; j++) {
										strBuf.push(textItems[j].str);
									}
									_this2.pageContents[i] = strBuf.join(
									'');
									extractTextCapability.resolve(i);
								},
								function(reason) {
									console.error('Unable to get page ' + (
											i + 1) + ' text content',
										reason);
									_this2.pageContents[i] = '';
									extractTextCapability.resolve(i);
								});
						});
					};
					for (var i = 0, ii = this.pdfViewer.pagesCount; i < ii; i++) {
						_loop(i, ii);
					}
				}
			}, {
				key: 'executeCommand',
				value: function executeCommand(cmd, state) {
					var _this3 = this;
					if (this.state === null || cmd !== 'findagain') {
						this.dirtyMatch = true;
					}
					this.state = state;
					this.updateUIState(FindState.PENDING);
					this._firstPagePromise.then(function() {
						_this3.extractText();
						clearTimeout(_this3.findTimeout);
						if (cmd === 'find') {
							_this3.findTimeout = setTimeout(_this3.nextMatch.bind(
								_this3), FIND_TIMEOUT);
						} else {
							_this3.nextMatch();
						}
					});
				}
			}, {
				key: 'updatePage',
				value: function updatePage(index) {
					if (this.selected.pageIdx === index) {
						this.pdfViewer.currentPageNumber = index + 1;
					}
					var page = this.pdfViewer.getPageView(index);
					if (page.textLayer) {
						page.textLayer.updateMatches();
					}
				}
			}, {
				key: 'nextMatch',
				value: function nextMatch() {
					var _this4 = this;
					var previous = this.state.findPrevious;
					var currentPageIndex = this.pdfViewer.currentPageNumber - 1;
					var numPages = this.pdfViewer.pagesCount;
					this.active = true;
					if (this.dirtyMatch) {
						this.dirtyMatch = false;
						this.selected.pageIdx = this.selected.matchIdx = -1;
						this.offset.pageIdx = currentPageIndex;
						this.offset.matchIdx = null;
						this.hadMatch = false;
						this.resumePageIdx = null;
						this.pageMatches = [];
						this.matchCount = 0;
						this.pageMatchesLength = null;
						for (var i = 0; i < numPages; i++) {
							this.updatePage(i);
							if (!(i in this.pendingFindMatches)) {
								this.pendingFindMatches[i] = true;
								this.extractTextPromises[i].then(function(pageIdx) {
									delete _this4.pendingFindMatches[pageIdx];
									_this4.calcFindMatch(pageIdx);
								});
							}
						}
					}
					if (this.state.query === '') {
						this.updateUIState(FindState.FOUND);
						return;
					}
					if (this.resumePageIdx) {
						return;
					}
					var offset = this.offset;
					this.pagesToSearch = numPages;
					if (offset.matchIdx !== null) {
						var numPageMatches = this.pageMatches[offset.pageIdx].length;
						if (!previous && offset.matchIdx + 1 < numPageMatches || previous &&
							offset.matchIdx > 0) {
							this.hadMatch = true;
							offset.matchIdx = previous ? offset.matchIdx - 1 : offset
								.matchIdx + 1;
							this.updateMatch(true);
							return;
						}
						this.advanceOffsetPage(previous);
					}
					this.nextPageMatch();
				}
			}, {
				key: 'matchesReady',
				value: function matchesReady(matches) {
					var offset = this.offset;
					var numMatches = matches.length;
					var previous = this.state.findPrevious;
					if (numMatches) {
						this.hadMatch = true;
						offset.matchIdx = previous ? numMatches - 1 : 0;
						this.updateMatch(true);
						return true;
					}
					this.advanceOffsetPage(previous);
					if (offset.wrapped) {
						offset.matchIdx = null;
						if (this.pagesToSearch < 0) {
							this.updateMatch(false);
							return true;
						}
					}
					return false;
				}
			}, {
				key: 'updateMatchPosition',
				value: function updateMatchPosition(pageIndex, matchIndex, elements, beginIdx) {
					if (this.selected.matchIdx === matchIndex && this.selected.pageIdx ===
						pageIndex) {
						var spot = {
							top: FIND_SCROLL_OFFSET_TOP,
							left: FIND_SCROLL_OFFSET_LEFT
						};
						(0,
							_ui_utils.scrollIntoView)(elements[beginIdx], spot, true);
					}
				}
			}, {
				key: 'nextPageMatch',
				value: function nextPageMatch() {
					if (this.resumePageIdx !== null) {
						console.error('There can only be one pending page.');
					}
					var matches = null;
					do {
						var pageIdx = this.offset.pageIdx;
						matches = this.pageMatches[pageIdx];
						if (!matches) {
							this.resumePageIdx = pageIdx;
							break;
						}
					} while (!this.matchesReady(matches));
				}
			}, {
				key: 'advanceOffsetPage',
				value: function advanceOffsetPage(previous) {
					var offset = this.offset;
					var numPages = this.extractTextPromises.length;
					offset.pageIdx = previous ? offset.pageIdx - 1 : offset.pageIdx + 1;
					offset.matchIdx = null;
					this.pagesToSearch--;
					if (offset.pageIdx >= numPages || offset.pageIdx < 0) {
						offset.pageIdx = previous ? numPages - 1 : 0;
						offset.wrapped = true;
					}
				}
			}, {
				key: 'updateMatch',
				value: function updateMatch() {
					var found = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : false;
					var state = FindState.NOT_FOUND;
					var wrapped = this.offset.wrapped;
					this.offset.wrapped = false;
					if (found) {
						var previousPage = this.selected.pageIdx;
						this.selected.pageIdx = this.offset.pageIdx;
						this.selected.matchIdx = this.offset.matchIdx;
						state = wrapped ? FindState.WRAPPED : FindState.FOUND;
						if (previousPage !== -1 && previousPage !== this.selected.pageIdx) {
							this.updatePage(previousPage);
						}
					}
					this.updateUIState(state, this.state.findPrevious);
					if (this.selected.pageIdx !== -1) {
						this.updatePage(this.selected.pageIdx);
					}
				}
			}, {
				key: 'updateUIResultsCount',
				value: function updateUIResultsCount() {
					if (this.onUpdateResultsCount) {
						this.onUpdateResultsCount(this.matchCount);
					}
				}
			}, {
				key: 'updateUIState',
				value: function updateUIState(state, previous) {
					if (this.onUpdateState) {
						this.onUpdateState(state, previous, this.matchCount);
					}
				}
			}]);
			return PDFFindController;
		}();
		exports.FindState = FindState;
		exports.PDFFindController = PDFFindController;
	}), /* 8 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		var DEFAULT_URL = pdf_file;;
		var pdfjsWebApp = void 0; {
			pdfjsWebApp = __webpack_require__(4);
		}; {
			__webpack_require__(29);
		}; {
			__webpack_require__(34);
		}

		function getViewerConfiguration() {
			return {
				appContainer: document.body,
				mainContainer: document.getElementById('viewerContainer'),
				viewerContainer: document.getElementById('viewer'),
				eventBus: null,
				toolbar: {
					container: document.getElementById('toolbarViewer'),
					numPages: document.getElementById('numPages'),
					pageNumber: document.getElementById('pageNumber'),
					scaleSelectContainer: document.getElementById('scaleSelectContainer'),
					scaleSelect: document.getElementById('scaleSelect'),
					customScaleOption: document.getElementById('customScaleOption'),
					previous: document.getElementById('previous'),
					next: document.getElementById('next'),
					zoomIn: document.getElementById('zoomIn'),
					zoomOut: document.getElementById('zoomOut'),
					viewFind: document.getElementById('viewFind'),
					openFile: document.getElementById('openFile'),
					print: document.getElementById('print'),
					presentationModeButton: document.getElementById('presentationMode'),
					download: document.getElementById('download'),
					viewBookmark: document.getElementById('viewBookmark')
				},
				secondaryToolbar: {
					toolbar: document.getElementById('secondaryToolbar'),
					toggleButton: document.getElementById('secondaryToolbarToggle'),
					toolbarButtonContainer: document.getElementById('secondaryToolbarButtonContainer'),
					presentationModeButton: document.getElementById('secondaryPresentationMode'),
					openFileButton: document.getElementById('secondaryOpenFile'),
					printButton: document.getElementById('secondaryPrint'),
					downloadButton: document.getElementById('secondaryDownload'),
					viewBookmarkButton: document.getElementById('secondaryViewBookmark'),
					firstPageButton: document.getElementById('firstPage'),
					lastPageButton: document.getElementById('lastPage'),
					pageRotateCwButton: document.getElementById('pageRotateCw'),
					pageRotateCcwButton: document.getElementById('pageRotateCcw'),
					cursorSelectToolButton: document.getElementById('cursorSelectTool'),
					cursorHandToolButton: document.getElementById('cursorHandTool'),
					documentPropertiesButton: document.getElementById('documentProperties')
				},
				fullscreen: {
					contextFirstPage: document.getElementById('contextFirstPage'),
					contextLastPage: document.getElementById('contextLastPage'),
					contextPageRotateCw: document.getElementById('contextPageRotateCw'),
					contextPageRotateCcw: document.getElementById('contextPageRotateCcw')
				},
				sidebar: {
					mainContainer: document.getElementById('mainContainer'),
					outerContainer: document.getElementById('outerContainer'),
					toggleButton: document.getElementById('sidebarToggle'),
					thumbnailButton: document.getElementById('viewThumbnail'),
					outlineButton: document.getElementById('viewOutline'),
					attachmentsButton: document.getElementById('viewAttachments'),
					thumbnailView: document.getElementById('thumbnailView'),
					outlineView: document.getElementById('outlineView'),
					attachmentsView: document.getElementById('attachmentsView')
				},
				findBar: {
					bar: document.getElementById('findbar'),
					toggleButton: document.getElementById('viewFind'),
					findField: document.getElementById('findInput'),
					highlightAllCheckbox: document.getElementById('findHighlightAll'),
					caseSensitiveCheckbox: document.getElementById('findMatchCase'),
					findMsg: document.getElementById('findMsg'),
					findResultsCount: document.getElementById('findResultsCount'),
					findStatusIcon: document.getElementById('findStatusIcon'),
					findPreviousButton: document.getElementById('findPrevious'),
					findNextButton: document.getElementById('findNext')
				},
				passwordOverlay: {
					overlayName: 'passwordOverlay',
					container: document.getElementById('passwordOverlay'),
					label: document.getElementById('passwordText'),
					input: document.getElementById('password'),
					submitButton: document.getElementById('passwordSubmit'),
					cancelButton: document.getElementById('passwordCancel')
				},
				documentProperties: {
					overlayName: 'documentPropertiesOverlay',
					container: document.getElementById('documentPropertiesOverlay'),
					closeButton: document.getElementById('documentPropertiesClose'),
					fields: {
						'fileName': document.getElementById('fileNameField'),
						'fileSize': document.getElementById('fileSizeField'),
						'title': document.getElementById('titleField'),
						'author': document.getElementById('authorField'),
						'subject': document.getElementById('subjectField'),
						'keywords': document.getElementById('keywordsField'),
						'creationDate': document.getElementById('creationDateField'),
						'modificationDate': document.getElementById('modificationDateField'),
						'creator': document.getElementById('creatorField'),
						'producer': document.getElementById('producerField'),
						'version': document.getElementById('versionField'),
						'pageCount': document.getElementById('pageCountField')
					}
				},
				errorWrapper: {
					container: document.getElementById('errorWrapper'),
					errorMessage: document.getElementById('errorMessage'),
					closeButton: document.getElementById('errorClose'),
					errorMoreInfo: document.getElementById('errorMoreInfo'),
					moreInfoButton: document.getElementById('errorShowMore'),
					lessInfoButton: document.getElementById('errorShowLess')
				},
				printContainer: document.getElementById('printContainer'),
				openFileInputName: 'fileInput',
				debuggerScriptPath: './debugger.js',
				defaultUrl: DEFAULT_URL
			};
		}

		function webViewerLoad() {
			var config = getViewerConfiguration();
			window.PDFViewerApplication = pdfjsWebApp.PDFViewerApplication;
			pdfjsWebApp.PDFViewerApplication.run(config);
		}
		if (document.readyState === 'interactive' || document.readyState === 'complete') {
			webViewerLoad();
		} else {
			document.addEventListener('DOMContentLoaded', webViewerLoad, true);
		}
	}), /* 9 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});

		function GrabToPan(options) {
			this.element = options.element;
			this.document = options.element.ownerDocument;
			if (typeof options.ignoreTarget === 'function') {
				this.ignoreTarget = options.ignoreTarget;
			}
			this.onActiveChanged = options.onActiveChanged;
			this.activate = this.activate.bind(this);
			this.deactivate = this.deactivate.bind(this);
			this.toggle = this.toggle.bind(this);
			this._onmousedown = this._onmousedown.bind(this);
			this._onmousemove = this._onmousemove.bind(this);
			this._endPan = this._endPan.bind(this);
			var overlay = this.overlay = document.createElement('div');
			overlay.className = 'grab-to-pan-grabbing';
		}
		GrabToPan.prototype = {
			CSS_CLASS_GRAB: 'grab-to-pan-grab',
			activate: function GrabToPan_activate() {
				if (!this.active) {
					this.active = true;
					this.element.addEventListener('mousedown', this._onmousedown, true);
					this.element.classList.add(this.CSS_CLASS_GRAB);
					if (this.onActiveChanged) {
						this.onActiveChanged(true);
					}
				}
			},
			deactivate: function GrabToPan_deactivate() {
				if (this.active) {
					this.active = false;
					this.element.removeEventListener('mousedown', this._onmousedown, true);
					this._endPan();
					this.element.classList.remove(this.CSS_CLASS_GRAB);
					if (this.onActiveChanged) {
						this.onActiveChanged(false);
					}
				}
			},
			toggle: function GrabToPan_toggle() {
				if (this.active) {
					this.deactivate();
				} else {
					this.activate();
				}
			},
			ignoreTarget: function GrabToPan_ignoreTarget(node) {
				return node[matchesSelector](
					'a[href], a[href] *, input, textarea, button, button *, select, option');
			},
			_onmousedown: function GrabToPan__onmousedown(event) {
				if (event.button !== 0 || this.ignoreTarget(event.target)) {
					return;
				}
				if (event.originalTarget) {
					try {
						event.originalTarget.tagName;
					} catch (e) {
						return;
					}
				}
				this.scrollLeftStart = this.element.scrollLeft;
				this.scrollTopStart = this.element.scrollTop;
				this.clientXStart = event.clientX;
				this.clientYStart = event.clientY;
				this.document.addEventListener('mousemove', this._onmousemove, true);
				this.document.addEventListener('mouseup', this._endPan, true);
				this.element.addEventListener('scroll', this._endPan, true);
				event.preventDefault();
				event.stopPropagation();
				var focusedElement = document.activeElement;
				if (focusedElement && !focusedElement.contains(event.target)) {
					focusedElement.blur();
				}
			},
			_onmousemove: function GrabToPan__onmousemove(event) {
				this.element.removeEventListener('scroll', this._endPan, true);
				if (isLeftMouseReleased(event)) {
					this._endPan();
					return;
				}
				var xDiff = event.clientX - this.clientXStart;
				var yDiff = event.clientY - this.clientYStart;
				var scrollTop = this.scrollTopStart - yDiff;
				var scrollLeft = this.scrollLeftStart - xDiff;
				if (this.element.scrollTo) {
					this.element.scrollTo({
						top: scrollTop,
						left: scrollLeft,
						behavior: 'instant'
					});
				} else {
					this.element.scrollTop = scrollTop;
					this.element.scrollLeft = scrollLeft;
				}
				if (!this.overlay.parentNode) {
					document.body.appendChild(this.overlay);
				}
			},
			_endPan: function GrabToPan__endPan() {
				this.element.removeEventListener('scroll', this._endPan, true);
				this.document.removeEventListener('mousemove', this._onmousemove, true);
				this.document.removeEventListener('mouseup', this._endPan, true);
				this.overlay.remove();
			}
		};
		var matchesSelector;
		['webkitM', 'mozM', 'msM', 'oM', 'm'].some(function(prefix) {
			var name = prefix + 'atches';
			if (name in document.documentElement) {
				matchesSelector = name;
			}
			name += 'Selector';
			if (name in document.documentElement) {
				matchesSelector = name;
			}
			return matchesSelector;
		});
		var isNotIEorIsIE10plus = !document.documentMode || document.documentMode > 9;
		var chrome = window.chrome;
		var isChrome15OrOpera15plus = chrome && (chrome.webstore || chrome.app);
		var isSafari6plus = /Apple/.test(navigator.vendor) && /Version\/([6-9]\d*|[1-5]\d+)/.test(navigator
			.userAgent);

		function isLeftMouseReleased(event) {
			if ('buttons' in event && isNotIEorIsIE10plus) {
				return !(event.buttons & 1);
			}
			if (isChrome15OrOpera15plus || isSafari6plus) {
				return event.which === 0;
			}
		}
		exports.GrabToPan = GrabToPan;
	}), /* 10 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFSidebar = exports.SidebarView = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);
		var _pdf_rendering_queue = __webpack_require__(3);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var UI_NOTIFICATION_CLASS = 'pdfSidebarNotification';
		var SidebarView = {
			NONE: 0,
			THUMBS: 1,
			OUTLINE: 2,
			ATTACHMENTS: 3
		};
		var PDFSidebar = function() {
			function PDFSidebar(options) {
				var l10n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _ui_utils
					.NullL10n;
				_classCallCheck(this, PDFSidebar);
				this.isOpen = false;
				this.active = SidebarView.THUMBS;
				this.isInitialViewSet = false;
				this.onToggled = null;
				this.pdfViewer = options.pdfViewer;
				this.pdfThumbnailViewer = options.pdfThumbnailViewer;
				this.pdfOutlineViewer = options.pdfOutlineViewer;
				this.mainContainer = options.mainContainer;
				this.outerContainer = options.outerContainer;
				this.eventBus = options.eventBus;
				this.toggleButton = options.toggleButton;
				this.thumbnailButton = options.thumbnailButton;
				this.outlineButton = options.outlineButton;
				this.attachmentsButton = options.attachmentsButton;
				this.thumbnailView = options.thumbnailView;
				this.outlineView = options.outlineView;
				this.attachmentsView = options.attachmentsView;
				this.disableNotification = options.disableNotification || false;
				this.l10n = l10n;
				this._addEventListeners();
			}
			_createClass(PDFSidebar, [{
				key: 'reset',
				value: function reset() {
					this.isInitialViewSet = false;
					this._hideUINotification(null);
					this.switchView(SidebarView.THUMBS);
					this.outlineButton.disabled = false;
					this.attachmentsButton.disabled = false;
				}
			}, {
				key: 'setInitialView',
				value: function setInitialView() {
					var view = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : SidebarView.NONE;
					if (this.isInitialViewSet) {
						return;
					}
					this.isInitialViewSet = true;
					if (this.isOpen && view === SidebarView.NONE) {
						this._dispatchEvent();
						return;
					}
					var isViewPreserved = view === this.visibleView;
					this.switchView(view, true);
					if (isViewPreserved) {
						this._dispatchEvent();
					}
				}
			}, {
				key: 'switchView',
				value: function switchView(view) {
					var forceOpen = arguments.length > 1 && arguments[1] !== undefined ?
						arguments[1] : false;
					if (view === SidebarView.NONE) {
						this.close();
						return;
					}
					var isViewChanged = view !== this.active;
					var shouldForceRendering = false;
					switch (view) {
						case SidebarView.THUMBS:
							this.thumbnailButton.classList.add('toggled');
							this.outlineButton.classList.remove('toggled');
							this.attachmentsButton.classList.remove('toggled');
							this.thumbnailView.classList.remove('hidden');
							this.outlineView.classList.add('hidden');
							this.attachmentsView.classList.add('hidden');
							if (this.isOpen && isViewChanged) {
								this._updateThumbnailViewer();
								shouldForceRendering = true;
							}
							break;
						case SidebarView.OUTLINE:
							if (this.outlineButton.disabled) {
								return;
							}
							this.thumbnailButton.classList.remove('toggled');
							this.outlineButton.classList.add('toggled');
							this.attachmentsButton.classList.remove('toggled');
							this.thumbnailView.classList.add('hidden');
							this.outlineView.classList.remove('hidden');
							this.attachmentsView.classList.add('hidden');
							break;
						case SidebarView.ATTACHMENTS:
							if (this.attachmentsButton.disabled) {
								return;
							}
							this.thumbnailButton.classList.remove('toggled');
							this.outlineButton.classList.remove('toggled');
							this.attachmentsButton.classList.add('toggled');
							this.thumbnailView.classList.add('hidden');
							this.outlineView.classList.add('hidden');
							this.attachmentsView.classList.remove('hidden');
							break;
						default:
							console.error('PDFSidebar_switchView: "' + view +
								'" is an unsupported value.');
							return;
					}
					this.active = view | 0;
					if (forceOpen && !this.isOpen) {
						this.open();
						return;
					}
					if (shouldForceRendering) {
						this._forceRendering();
					}
					if (isViewChanged) {
						this._dispatchEvent();
					}
					this._hideUINotification(this.active);
				}
			}, {
				key: 'open',
				value: function open() {
					if (this.isOpen) {
						return;
					}
					this.isOpen = true;
					this.toggleButton.classList.add('toggled');
					this.outerContainer.classList.add('sidebarMoving');
					this.outerContainer.classList.add('sidebarOpen');
					if (this.active === SidebarView.THUMBS) {
						this._updateThumbnailViewer();
					}
					this._forceRendering();
					this._dispatchEvent();
					this._hideUINotification(this.active);
				}
			}, {
				key: 'close',
				value: function close() {
					if (!this.isOpen) {
						return;
					}
					this.isOpen = false;
					this.toggleButton.classList.remove('toggled');
					this.outerContainer.classList.add('sidebarMoving');
					this.outerContainer.classList.remove('sidebarOpen');
					this._forceRendering();
					this._dispatchEvent();
				}
			}, {
				key: 'toggle',
				value: function toggle() {
					if (this.isOpen) {
						this.close();
					} else {
						this.open();
					}
				}
			}, {
				key: '_dispatchEvent',
				value: function _dispatchEvent() {
					this.eventBus.dispatch('sidebarviewchanged', {
						source: this,
						view: this.visibleView
					});
				}
			}, {
				key: '_forceRendering',
				value: function _forceRendering() {
					if (this.onToggled) {
						this.onToggled();
					} else {
						this.pdfViewer.forceRendering();
						this.pdfThumbnailViewer.forceRendering();
					}
				}
			}, {
				key: '_updateThumbnailViewer',
				value: function _updateThumbnailViewer() {
					var pdfViewer = this.pdfViewer,
						pdfThumbnailViewer = this.pdfThumbnailViewer;
					var pagesCount = pdfViewer.pagesCount;
					for (var pageIndex = 0; pageIndex < pagesCount; pageIndex++) {
						var pageView = pdfViewer.getPageView(pageIndex);
						if (pageView && pageView.renderingState === _pdf_rendering_queue
							.RenderingStates.FINISHED) {
							var thumbnailView = pdfThumbnailViewer.getThumbnail(pageIndex);
							thumbnailView.setImage(pageView);
						}
					}
					pdfThumbnailViewer.scrollThumbnailIntoView(pdfViewer.currentPageNumber);
				}
			}, {
				key: '_showUINotification',
				value: function _showUINotification(view) {
					var _this = this;
					if (this.disableNotification) {
						return;
					}
					this.l10n.get('toggle_sidebar_notification.title', null,
						'Toggle Sidebar (document contains outline/attachments)').then(
						function(msg) {
							_this.toggleButton.title = msg;
						});
					if (!this.isOpen) {
						this.toggleButton.classList.add(UI_NOTIFICATION_CLASS);
					} else if (view === this.active) {
						return;
					}
					switch (view) {
						case SidebarView.OUTLINE:
							this.outlineButton.classList.add(UI_NOTIFICATION_CLASS);
							break;
						case SidebarView.ATTACHMENTS:
							this.attachmentsButton.classList.add(UI_NOTIFICATION_CLASS);
							break;
					}
				}
			}, {
				key: '_hideUINotification',
				value: function _hideUINotification(view) {
					var _this2 = this;
					if (this.disableNotification) {
						return;
					}
					var removeNotification = function removeNotification(view) {
						switch (view) {
							case SidebarView.OUTLINE:
								_this2.outlineButton.classList.remove(
									UI_NOTIFICATION_CLASS);
								break;
							case SidebarView.ATTACHMENTS:
								_this2.attachmentsButton.classList.remove(
									UI_NOTIFICATION_CLASS);
								break;
						}
					};
					if (!this.isOpen && view !== null) {
						return;
					}
					this.toggleButton.classList.remove(UI_NOTIFICATION_CLASS);
					if (view !== null) {
						removeNotification(view);
						return;
					}
					for (view in SidebarView) {
						removeNotification(SidebarView[view]);
					}
					this.l10n.get('toggle_sidebar.title', null, 'Toggle Sidebar').then(
						function(msg) {
							_this2.toggleButton.title = msg;
						});
				}
			}, {
				key: '_addEventListeners',
				value: function _addEventListeners() {
					var _this3 = this;
					this.mainContainer.addEventListener('transitionend', function(evt) {
						if (evt.target === _this3.mainContainer) {
							_this3.outerContainer.classList.remove('sidebarMoving');
						}
					});
					this.thumbnailButton.addEventListener('click', function() {
						_this3.switchView(SidebarView.THUMBS);
					});
					this.outlineButton.addEventListener('click', function() {
						_this3.switchView(SidebarView.OUTLINE);
					});
					this.outlineButton.addEventListener('dblclick', function() {
						_this3.pdfOutlineViewer.toggleOutlineTree();
					});
					this.attachmentsButton.addEventListener('click', function() {
						_this3.switchView(SidebarView.ATTACHMENTS);
					});
					this.eventBus.on('outlineloaded', function(evt) {
						var outlineCount = evt.outlineCount;
						_this3.outlineButton.disabled = !outlineCount;
						if (outlineCount) {
							_this3._showUINotification(SidebarView.OUTLINE);
						} else if (_this3.active === SidebarView.OUTLINE) {
							_this3.switchView(SidebarView.THUMBS);
						}
					});
					this.eventBus.on('attachmentsloaded', function(evt) {
						if (evt.attachmentsCount) {
							_this3.attachmentsButton.disabled = false;
							_this3._showUINotification(SidebarView.ATTACHMENTS);
							return;
						}
						Promise.resolve().then(function() {
							if (_this3.attachmentsView.hasChildNodes()) {
								return;
							}
							_this3.attachmentsButton.disabled = true;
							if (_this3.active === SidebarView.ATTACHMENTS) {
								_this3.switchView(SidebarView.THUMBS);
							}
						});
					});
					this.eventBus.on('presentationmodechanged', function(evt) {
						if (!evt.active && !evt.switchInProgress && _this3
							.isThumbnailViewVisible) {
							_this3._updateThumbnailViewer();
						}
					});
				}
			}, {
				key: 'visibleView',
				get: function get() {
					return this.isOpen ? this.active : SidebarView.NONE;
				}
			}, {
				key: 'isThumbnailViewVisible',
				get: function get() {
					return this.isOpen && this.active === SidebarView.THUMBS;
				}
			}, {
				key: 'isOutlineViewVisible',
				get: function get() {
					return this.isOpen && this.active === SidebarView.OUTLINE;
				}
			}, {
				key: 'isAttachmentsViewVisible',
				get: function get() {
					return this.isOpen && this.active === SidebarView.ATTACHMENTS;
				}
			}]);
			return PDFSidebar;
		}();
		exports.SidebarView = SidebarView;
		exports.PDFSidebar = PDFSidebar;
	}), /* 11 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var OverlayManager = function() {
			function OverlayManager() {
				_classCallCheck(this, OverlayManager);
				this._overlays = {};
				this._active = null;
				this._keyDownBound = this._keyDown.bind(this);
			}
			_createClass(OverlayManager, [{
				key: 'register',
				value: function register(name, element) {
					var _this = this;
					var callerCloseMethod = arguments.length > 2 && arguments[2] !==
						undefined ? arguments[2] : null;
					var canForceClose = arguments.length > 3 && arguments[3] !== undefined ?
						arguments[3] : false;
					return new Promise(function(resolve) {
						var container = void 0;
						if (!name || !element || !(container = element
							.parentNode)) {
							throw new Error('Not enough parameters.');
						} else if (_this._overlays[name]) {
							throw new Error('The overlay is already registered.');
						}
						_this._overlays[name] = {
							element: element,
							container: container,
							callerCloseMethod: callerCloseMethod,
							canForceClose: canForceClose
						};
						resolve();
					});
				}
			}, {
				key: 'unregister',
				value: function unregister(name) {
					var _this2 = this;
					return new Promise(function(resolve) {
						if (!_this2._overlays[name]) {
							throw new Error('The overlay does not exist.');
						} else if (_this2._active === name) {
							throw new Error(
								'The overlay cannot be removed while it is active.'
								);
						}
						delete _this2._overlays[name];
						resolve();
					});
				}
			}, {
				key: 'open',
				value: function open(name) {
					var _this3 = this;
					return new Promise(function(resolve) {
						if (!_this3._overlays[name]) {
							throw new Error('The overlay does not exist.');
						} else if (_this3._active) {
							if (_this3._overlays[name].canForceClose) {
								_this3._closeThroughCaller();
							} else if (_this3._active === name) {
								throw new Error('The overlay is already active.');
							} else {
								throw new Error(
									'Another overlay is currently active.');
							}
						}
						_this3._active = name;
						_this3._overlays[_this3._active].element.classList.remove(
							'hidden');
						_this3._overlays[_this3._active].container.classList.remove(
							'hidden');
						window.addEventListener('keydown', _this3._keyDownBound);
						resolve();
					});
				}
			}, {
				key: 'close',
				value: function close(name) {
					var _this4 = this;
					return new Promise(function(resolve) {
						if (!_this4._overlays[name]) {
							throw new Error('The overlay does not exist.');
						} else if (!_this4._active) {
							throw new Error('The overlay is currently not active.');
						} else if (_this4._active !== name) {
							throw new Error('Another overlay is currently active.');
						}
						_this4._overlays[_this4._active].container.classList.add(
							'hidden');
						_this4._overlays[_this4._active].element.classList.add(
							'hidden');
						_this4._active = null;
						window.removeEventListener('keydown', _this4._keyDownBound);
						resolve();
					});
				}
			}, {
				key: '_keyDown',
				value: function _keyDown(evt) {
					if (this._active && evt.keyCode === 27) {
						this._closeThroughCaller();
						evt.preventDefault();
					}
				}
			}, {
				key: '_closeThroughCaller',
				value: function _closeThroughCaller() {
					if (this._overlays[this._active].callerCloseMethod) {
						this._overlays[this._active].callerCloseMethod();
					}
					if (this._active) {
						this.close(this._active);
					}
				}
			}, {
				key: 'active',
				get: function get() {
					return this._active;
				}
			}]);
			return OverlayManager;
		}();
		exports.OverlayManager = OverlayManager;
	}), /* 12 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PasswordPrompt = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var PasswordPrompt = function() {
			function PasswordPrompt(options, overlayManager) {
				var _this = this;
				var l10n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _ui_utils
					.NullL10n;
				_classCallCheck(this, PasswordPrompt);
				this.overlayName = options.overlayName;
				this.container = options.container;
				this.label = options.label;
				this.input = options.input;
				this.submitButton = options.submitButton;
				this.cancelButton = options.cancelButton;
				this.overlayManager = overlayManager;
				this.l10n = l10n;
				this.updateCallback = null;
				this.reason = null;
				this.submitButton.addEventListener('click', this.verify.bind(this));
				this.cancelButton.addEventListener('click', this.close.bind(this));
				this.input.addEventListener('keydown', function(e) {
					if (e.keyCode === 13) {
						_this.verify();
					}
				});
				this.overlayManager.register(this.overlayName, this.container, this.close.bind(this), true);
			}
			_createClass(PasswordPrompt, [{
				key: 'open',
				value: function open() {
					var _this2 = this;
					this.overlayManager.open(this.overlayName).then(function() {
						_this2.input.focus();
						var promptString = void 0;
						if (_this2.reason === _pdfjsLib.PasswordResponses
							.INCORRECT_PASSWORD) {
							promptString = _this2.l10n.get('password_invalid', null,
								'Invalid password. Please try again.');
						} else {
							promptString = _this2.l10n.get('password_label', null,
								'Enter the password to open this PDF file.');
						}
						promptString.then(function(msg) {
							_this2.label.textContent = msg;
						});
					});
				}
			}, {
				key: 'close',
				value: function close() {
					var _this3 = this;
					this.overlayManager.close(this.overlayName).then(function() {
						_this3.input.value = '';
					});
				}
			}, {
				key: 'verify',
				value: function verify() {
					var password = this.input.value;
					if (password && password.length > 0) {
						this.close();
						return this.updateCallback(password);
					}
				}
			}, {
				key: 'setUpdateCallback',
				value: function setUpdateCallback(updateCallback, reason) {
					this.updateCallback = updateCallback;
					this.reason = reason;
				}
			}]);
			return PasswordPrompt;
		}();
		exports.PasswordPrompt = PasswordPrompt;
	}), /* 13 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFAttachmentViewer = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var PDFAttachmentViewer = function() {
			function PDFAttachmentViewer(_ref) {
				var container = _ref.container,
					eventBus = _ref.eventBus,
					downloadManager = _ref.downloadManager;
				_classCallCheck(this, PDFAttachmentViewer);
				this.container = container;
				this.eventBus = eventBus;
				this.downloadManager = downloadManager;
				this.reset();
				this.eventBus.on('fileattachmentannotation', this._appendAttachment.bind(this));
			}
			_createClass(PDFAttachmentViewer, [{
				key: 'reset',
				value: function reset() {
					var keepRenderedCapability = arguments.length > 0 && arguments[0] !==
						undefined ? arguments[0] : false;
					this.attachments = null;
					this.container.textContent = '';
					if (!keepRenderedCapability) {
						this._renderedCapability = (0,
							_pdfjsLib.createPromiseCapability)();
					}
				}
			}, {
				key: '_dispatchEvent',
				value: function _dispatchEvent(attachmentsCount) {
					this._renderedCapability.resolve();
					this.eventBus.dispatch('attachmentsloaded', {
						source: this,
						attachmentsCount: attachmentsCount
					});
				}
			}, {
				key: '_bindPdfLink',
				value: function _bindPdfLink(button, content, filename) {
					if (_pdfjsLib.PDFJS.disableCreateObjectURL) {
						throw new Error('bindPdfLink: ' +
							'Unsupported "PDFJS.disableCreateObjectURL" value.');
					}
					var blobUrl = void 0;
					button.onclick = function() {
						if (!blobUrl) {
							blobUrl = (0,
								_pdfjsLib.createObjectURL)(content,
								'application/pdf');
						}
						var viewerUrl = void 0;
						viewerUrl = '?file=' + encodeURIComponent(blobUrl + '#' +
							filename);
						window.open(viewerUrl);
						return false;
					};
				}
			}, {
				key: '_bindLink',
				value: function _bindLink(button, content, filename) {
					var _this = this;
					button.onclick = function() {
						_this.downloadManager.downloadData(content, filename, '');
						return false;
					};
				}
			}, {
				key: 'render',
				value: function render(_ref2) {
					var attachments = _ref2.attachments,
						_ref2$keepRenderedCap = _ref2.keepRenderedCapability,
						keepRenderedCapability = _ref2$keepRenderedCap === undefined ?
						false : _ref2$keepRenderedCap;
					var attachmentsCount = 0;
					if (this.attachments) {
						this.reset(keepRenderedCapability === true);
					}
					this.attachments = attachments || null;
					if (!attachments) {
						this._dispatchEvent(attachmentsCount);
						return;
					}
					var names = Object.keys(attachments).sort(function(a, b) {
						return a.toLowerCase().localeCompare(b.toLowerCase());
					});
					attachmentsCount = names.length;
					for (var i = 0; i < attachmentsCount; i++) {
						var item = attachments[names[i]];
						var filename = (0,
							_pdfjsLib.removeNullCharacters)((0,
							_pdfjsLib.getFilenameFromUrl)(item.filename));
						var div = document.createElement('div');
						div.className = 'attachmentsItem';
						var button = document.createElement('button');
						button.textContent = filename;
						if (/\.pdf$/i.test(filename) && !_pdfjsLib.PDFJS
							.disableCreateObjectURL) {
							this._bindPdfLink(button, item.content, filename);
						} else {
							this._bindLink(button, item.content, filename);
						}
						div.appendChild(button);
						this.container.appendChild(div);
					}
					this._dispatchEvent(attachmentsCount);
				}
			}, {
				key: '_appendAttachment',
				value: function _appendAttachment(_ref3) {
					var _this2 = this;
					var id = _ref3.id,
						filename = _ref3.filename,
						content = _ref3.content;
					this._renderedCapability.promise.then(function() {
						var attachments = _this2.attachments;
						if (!attachments) {
							attachments = Object.create(null);
						} else {
							for (var name in attachments) {
								if (id === name) {
									return;
								}
							}
						}
						attachments[id] = {
							filename: filename,
							content: content
						};
						_this2.render({
							attachments: attachments,
							keepRenderedCapability: true
						});
					});
				}
			}]);
			return PDFAttachmentViewer;
		}();
		exports.PDFAttachmentViewer = PDFAttachmentViewer;
	}), /* 14 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFDocumentProperties = undefined;
		var _slicedToArray = function() {
			function sliceIterator(arr, i) {
				var _arr = [];
				var _n = true;
				var _d = false;
				var _e = undefined;
				try {
					for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
						_arr.push(_s.value);
						if (i && _arr.length === i)
							break;
					}
				} catch (err) {
					_d = true;
					_e = err;
				} finally {
					try {
						if (!_n && _i["return"])
							_i["return"]();
					} finally {
						if (_d)
							throw _e;
					}
				}
				return _arr;
			}
			return function(arr, i) {
				if (Array.isArray(arr)) {
					return arr;
				} else if (Symbol.iterator in Object(arr)) {
					return sliceIterator(arr, i);
				} else {
					throw new TypeError("Invalid attempt to destructure non-iterable instance");
				}
			};
		}();
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var DEFAULT_FIELD_CONTENT = '-';
		var PDFDocumentProperties = function() {
			function PDFDocumentProperties(_ref, overlayManager) {
				var overlayName = _ref.overlayName,
					fields = _ref.fields,
					container = _ref.container,
					closeButton = _ref.closeButton;
				var l10n = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : _ui_utils
					.NullL10n;
				_classCallCheck(this, PDFDocumentProperties);
				this.overlayName = overlayName;
				this.fields = fields;
				this.container = container;
				this.overlayManager = overlayManager;
				this.l10n = l10n;
				this._reset();
				if (closeButton) {
					closeButton.addEventListener('click', this.close.bind(this));
				}
				this.overlayManager.register(this.overlayName, this.container, this.close.bind(this));
			}
			_createClass(PDFDocumentProperties, [{
				key: 'open',
				value: function open() {
					var _this = this;
					var freezeFieldData = function freezeFieldData(data) {
						Object.defineProperty(_this, 'fieldData', {
							value: Object.freeze(data),
							writable: false,
							enumerable: true,
							configurable: true
						});
					};
					Promise.all([this.overlayManager.open(this.overlayName), this
						._dataAvailableCapability.promise
					]).then(function() {
						if (_this.fieldData) {
							_this._updateUI();
							return;
						}
						_this.pdfDocument.getMetadata().then(function(_ref2) {
							var info = _ref2.info,
								metadata = _ref2.metadata;
							return Promise.all([info, metadata, _this
								._parseFileSize(_this
								.maybeFileSize), _this._parseDate(
									info.CreationDate), _this
								._parseDate(info.ModDate)
							]);
						}).then(function(_ref3) {
							var _ref4 = _slicedToArray(_ref3, 5),
								info = _ref4[0],
								metadata = _ref4[1],
								fileSize = _ref4[2],
								creationDate = _ref4[3],
								modificationDate = _ref4[4];
							freezeFieldData({
								'fileName': (0,
									_ui_utils
									.getPDFFileNameFromURL)(
									_this.url),
								'fileSize': fileSize,
								'title': info.Title,
								'author': info.Author,
								'subject': info.Subject,
								'keywords': info.Keywords,
								'creationDate': creationDate,
								'modificationDate': modificationDate,
								'creator': info.Creator,
								'producer': info.Producer,
								'version': info.PDFFormatVersion,
								'pageCount': _this.pdfDocument
									.numPages
							});
							_this._updateUI();
							return _this.pdfDocument.getDownloadInfo();
						}).then(function(_ref5) {
							var length = _ref5.length;
							return _this._parseFileSize(length);
						}).then(function(fileSize) {
							var data = (0,
								_ui_utils.cloneObj)(_this.fieldData);
							data['fileSize'] = fileSize;
							freezeFieldData(data);
							_this._updateUI();
						});
					});
				}
			}, {
				key: 'close',
				value: function close() {
					this.overlayManager.close(this.overlayName);
				}
			}, {
				key: 'setDocument',
				value: function setDocument(pdfDocument, url) {
					if (this.pdfDocument) {
						this._reset();
						this._updateUI(true);
					}
					if (!pdfDocument) {
						return;
					}
					this.pdfDocument = pdfDocument;
					this.url = url;
					this._dataAvailableCapability.resolve();
				}
			}, {
				key: 'setFileSize',
				value: function setFileSize(fileSize) {
					if (typeof fileSize === 'number' && fileSize > 0) {
						this.maybeFileSize = fileSize;
					}
				}
			}, {
				key: '_reset',
				value: function _reset() {
					this.pdfDocument = null;
					this.url = null;
					this.maybeFileSize = 0;
					delete this.fieldData;
					this._dataAvailableCapability = (0,
						_pdfjsLib.createPromiseCapability)();
				}
			}, {
				key: '_updateUI',
				value: function _updateUI() {
					var reset = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : false;
					if (reset || !this.fieldData) {
						for (var id in this.fields) {
							this.fields[id].textContent = DEFAULT_FIELD_CONTENT;
						}
						return;
					}
					if (this.overlayManager.active !== this.overlayName) {
						return;
					}
					for (var _id in this.fields) {
						var content = this.fieldData[_id];
						this.fields[_id].textContent = content || content === 0 ? content :
							DEFAULT_FIELD_CONTENT;
					}
				}
			}, {
				key: '_parseFileSize',
				value: function _parseFileSize() {
					var fileSize = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : 0;
					var kb = fileSize / 1024;
					if (!kb) {
						return Promise.resolve(undefined);
					} else if (kb < 1024) {
						return this.l10n.get('document_properties_kb', {
							size_kb: (+kb.toPrecision(3)).toLocaleString(),
							size_b: fileSize.toLocaleString()
						}, '{{size_kb}} KB ({{size_b}} bytes)');
					}
					return this.l10n.get('document_properties_mb', {
						size_mb: (+(kb / 1024).toPrecision(3)).toLocaleString(),
						size_b: fileSize.toLocaleString()
					}, '{{size_mb}} MB ({{size_b}} bytes)');
				}
			}, {
				key: '_parseDate',
				value: function _parseDate(inputDate) {
					if (!inputDate) {
						return;
					}
					var dateToParse = inputDate;
					if (dateToParse.substring(0, 2) === 'D:') {
						dateToParse = dateToParse.substring(2);
					}
					var year = parseInt(dateToParse.substring(0, 4), 10);
					var month = parseInt(dateToParse.substring(4, 6), 10) - 1;
					var day = parseInt(dateToParse.substring(6, 8), 10);
					var hours = parseInt(dateToParse.substring(8, 10), 10);
					var minutes = parseInt(dateToParse.substring(10, 12), 10);
					var seconds = parseInt(dateToParse.substring(12, 14), 10);
					var utRel = dateToParse.substring(14, 15);
					var offsetHours = parseInt(dateToParse.substring(15, 17), 10);
					var offsetMinutes = parseInt(dateToParse.substring(18, 20), 10);
					if (utRel === '-') {
						hours += offsetHours;
						minutes += offsetMinutes;
					} else if (utRel === '+') {
						hours -= offsetHours;
						minutes -= offsetMinutes;
					}
					var date = new Date(Date.UTC(year, month, day, hours, minutes,
					seconds));
					var dateString = date.toLocaleDateString();
					var timeString = date.toLocaleTimeString();
					return this.l10n.get('document_properties_date_string', {
						date: dateString,
						time: timeString
					}, '{{date}}, {{time}}');
				}
			}]);
			return PDFDocumentProperties;
		}();
		exports.PDFDocumentProperties = PDFDocumentProperties;
	}), /* 15 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFFindBar = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdf_find_controller = __webpack_require__(7);
		var _ui_utils = __webpack_require__(0);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var PDFFindBar = function() {
			function PDFFindBar(options) {
				var _this = this;
				var l10n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _ui_utils
					.NullL10n;
				_classCallCheck(this, PDFFindBar);
				this.opened = false;
				this.bar = options.bar || null;
				this.toggleButton = options.toggleButton || null;
				this.findField = options.findField || null;
				this.highlightAll = options.highlightAllCheckbox || null;
				this.caseSensitive = options.caseSensitiveCheckbox || null;
				this.findMsg = options.findMsg || null;
				this.findResultsCount = options.findResultsCount || null;
				this.findStatusIcon = options.findStatusIcon || null;
				this.findPreviousButton = options.findPreviousButton || null;
				this.findNextButton = options.findNextButton || null;
				this.findController = options.findController || null;
				this.eventBus = options.eventBus;
				this.l10n = l10n;
				if (this.findController === null) {
					throw new Error('PDFFindBar cannot be used without a ' + 'PDFFindController instance.');
				}
				this.toggleButton.addEventListener('click', function() {
					_this.toggle();
				});
				this.findField.addEventListener('input', function() {
					_this.dispatchEvent('');
				});
				this.bar.addEventListener('keydown', function(e) {
					switch (e.keyCode) {
						case 13:
							if (e.target === _this.findField) {
								_this.dispatchEvent('again', e.shiftKey);
							}
							break;
						case 27:
							_this.close();
							break;
					}
				});
				this.findPreviousButton.addEventListener('click', function() {
					_this.dispatchEvent('again', true);
				});
				this.findNextButton.addEventListener('click', function() {
					_this.dispatchEvent('again', false);
				});
				this.highlightAll.addEventListener('click', function() {
					_this.dispatchEvent('highlightallchange');
				});
				this.caseSensitive.addEventListener('click', function() {
					_this.dispatchEvent('casesensitivitychange');
				});
				this.eventBus.on('resize', this._adjustWidth.bind(this));
			}
			_createClass(PDFFindBar, [{
				key: 'reset',
				value: function reset() {
					this.updateUIState();
				}
			}, {
				key: 'dispatchEvent',
				value: function dispatchEvent(type, findPrev) {
					this.eventBus.dispatch('find', {
						source: this,
						type: type,
						query: this.findField.value,
						caseSensitive: this.caseSensitive.checked,
						phraseSearch: true,
						highlightAll: this.highlightAll.checked,
						findPrevious: findPrev
					});
				}
			}, {
				key: 'updateUIState',
				value: function updateUIState(state, previous, matchCount) {
					var _this2 = this;
					var notFound = false;
					var findMsg = '';
					var status = '';
					switch (state) {
						case _pdf_find_controller.FindState.FOUND:
							break;
						case _pdf_find_controller.FindState.PENDING:
							status = 'pending';
							break;
						case _pdf_find_controller.FindState.NOT_FOUND:
							findMsg = this.l10n.get('find_not_found', null,
								'Phrase not found');
							notFound = true;
							break;
						case _pdf_find_controller.FindState.WRAPPED:
							if (previous) {
								findMsg = this.l10n.get('find_reached_top', null,
									'Reached top of document, continued from bottom');
							} else {
								findMsg = this.l10n.get('find_reached_bottom', null,
									'Reached end of document, continued from top');
							}
							break;
					}
					if (notFound) {
						this.findField.classList.add('notFound');
					} else {
						this.findField.classList.remove('notFound');
					}
					this.findField.setAttribute('data-status', status);
					Promise.resolve(findMsg).then(function(msg) {
						_this2.findMsg.textContent = msg;
						_this2._adjustWidth();
					});
					this.updateResultsCount(matchCount);
				}
			}, {
				key: 'updateResultsCount',
				value: function updateResultsCount(matchCount) {
					if (!this.findResultsCount) {
						return;
					}
					if (!matchCount) {
						this.findResultsCount.classList.add('hidden');
						this.findResultsCount.textContent = '';
					} else {
						this.findResultsCount.textContent = matchCount.toLocaleString();
						this.findResultsCount.classList.remove('hidden');
					}
					this._adjustWidth();
				}
			}, {
				key: 'open',
				value: function open() {
					if (!this.opened) {
						this.opened = true;
						this.toggleButton.classList.add('toggled');
						this.bar.classList.remove('hidden');
					}
					this.findField.select();
					this.findField.focus();
					this._adjustWidth();
				}
			}, {
				key: 'close',
				value: function close() {
					if (!this.opened) {
						return;
					}
					this.opened = false;
					this.toggleButton.classList.remove('toggled');
					this.bar.classList.add('hidden');
					this.findController.active = false;
				}
			}, {
				key: 'toggle',
				value: function toggle() {
					if (this.opened) {
						this.close();
					} else {
						this.open();
					}
				}
			}, {
				key: '_adjustWidth',
				value: function _adjustWidth() {
					if (!this.opened) {
						return;
					}
					this.bar.classList.remove('wrapContainers');
					var findbarHeight = this.bar.clientHeight;
					var inputContainerHeight = this.bar.firstElementChild.clientHeight;
					if (findbarHeight > inputContainerHeight) {
						this.bar.classList.add('wrapContainers');
					}
				}
			}]);
			return PDFFindBar;
		}();
		exports.PDFFindBar = PDFFindBar;
	}), /* 16 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.isDestArraysEqual = exports.isDestHashesEqual = exports.PDFHistory = undefined;
		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
				return typeof obj;
			} :
			function(obj) {
				return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol
					.prototype ? "symbol" : typeof obj;
			};
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);
		var _dom_events = __webpack_require__(2);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var HASH_CHANGE_TIMEOUT = 1000;
		var POSITION_UPDATED_THRESHOLD = 50;
		var UPDATE_VIEWAREA_TIMEOUT = 1000;

		function getCurrentHash() {
			return document.location.hash;
		}

		function parseCurrentHash(linkService) {
			var hash = unescape(getCurrentHash()).substring(1);
			var params = (0,
				_ui_utils.parseQueryString)(hash);
			var page = params.page | 0;
			if (!(Number.isInteger(page) && page > 0 && page <= linkService.pagesCount)) {
				page = null;
			}
			return {
				hash: hash,
				page: page,
				rotation: linkService.rotation
			};
		}
		var PDFHistory = function() {
			function PDFHistory(_ref) {
				var _this = this;
				var linkService = _ref.linkService,
					eventBus = _ref.eventBus;
				_classCallCheck(this, PDFHistory);
				this.linkService = linkService;
				this.eventBus = eventBus || (0,
					_dom_events.getGlobalEventBus)();
				this.initialized = false;
				this.initialBookmark = null;
				this.initialRotation = null;
				this._boundEvents = Object.create(null);
				this._isViewerInPresentationMode = false;
				this._isPagesLoaded = false;
				this.eventBus.on('presentationmodechanged', function(evt) {
					_this._isViewerInPresentationMode = evt.active || evt.switchInProgress;
				});
				this.eventBus.on('pagesloaded', function(evt) {
					_this._isPagesLoaded = !!evt.pagesCount;
				});
			}
			_createClass(PDFHistory, [{
				key: 'initialize',
				value: function initialize(fingerprint) {
					var resetHistory = arguments.length > 1 && arguments[1] !== undefined ?
						arguments[1] : false;
					if (!fingerprint || typeof fingerprint !== 'string') {
						console.error(
							'PDFHistory.initialize: The "fingerprint" must be a non-empty string.'
							);
						return;
					}
					var reInitialized = this.initialized && this.fingerprint !==
					fingerprint;
					this.fingerprint = fingerprint;
					if (!this.initialized) {
						this._bindEvents();
					}
					var state = window.history.state;
					this.initialized = true;
					this.initialBookmark = null;
					this.initialRotation = null;
					this._popStateInProgress = false;
					this._blockHashChange = 0;
					this._currentHash = getCurrentHash();
					this._numPositionUpdates = 0;
					this._uid = this._maxUid = 0;
					this._destination = null;
					this._position = null;
					if (!this._isValidState(state) || resetHistory) {
						var _parseCurrentHash = parseCurrentHash(this.linkService),
							hash = _parseCurrentHash.hash,
							page = _parseCurrentHash.page,
							rotation = _parseCurrentHash.rotation;
						if (!hash || reInitialized || resetHistory) {
							this._pushOrReplaceState(null, true);
							return;
						}
						this._pushOrReplaceState({
							hash: hash,
							page: page,
							rotation: rotation
						}, true);
						return;
					}
					var destination = state.destination;
					this._updateInternalState(destination, state.uid, true);
					if (destination.rotation !== undefined) {
						this.initialRotation = destination.rotation;
					}
					if (destination.dest) {
						this.initialBookmark = JSON.stringify(destination.dest);
						this._destination.page = null;
					} else if (destination.hash) {
						this.initialBookmark = destination.hash;
					} else if (destination.page) {
						this.initialBookmark = 'page=' + destination.page;
					}
				}
			}, {
				key: 'push',
				value: function push(_ref2) {
					var _this2 = this;
					var namedDest = _ref2.namedDest,
						explicitDest = _ref2.explicitDest,
						pageNumber = _ref2.pageNumber;
					if (!this.initialized) {
						return;
					}
					if (namedDest && typeof namedDest !== 'string' || !(
							explicitDest instanceof Array) || !(Number.isInteger(
							pageNumber) && pageNumber > 0 && pageNumber <= this.linkService
							.pagesCount)) {
						console.error('PDFHistory.push: Invalid parameters.');
						return;
					}
					var hash = namedDest || JSON.stringify(explicitDest);
					if (!hash) {
						return;
					}
					var forceReplace = false;
					if (this._destination && (isDestHashesEqual(this._destination.hash,
							hash) || isDestArraysEqual(this._destination.dest,
							explicitDest))) {
						if (this._destination.page) {
							return;
						}
						forceReplace = true;
					}
					if (this._popStateInProgress && !forceReplace) {
						return;
					}
					this._pushOrReplaceState({
						dest: explicitDest,
						hash: hash,
						page: pageNumber,
						rotation: this.linkService.rotation
					}, forceReplace);
					if (!this._popStateInProgress) {
						this._popStateInProgress = true;
						Promise.resolve().then(function() {
							_this2._popStateInProgress = false;
						});
					}
				}
			}, {
				key: 'pushCurrentPosition',
				value: function pushCurrentPosition() {
					if (!this.initialized || this._popStateInProgress) {
						return;
					}
					this._tryPushCurrentPosition();
				}
			}, {
				key: 'back',
				value: function back() {
					if (!this.initialized || this._popStateInProgress) {
						return;
					}
					var state = window.history.state;
					if (this._isValidState(state) && state.uid > 0) {
						window.history.back();
					}
				}
			}, {
				key: 'forward',
				value: function forward() {
					if (!this.initialized || this._popStateInProgress) {
						return;
					}
					var state = window.history.state;
					if (this._isValidState(state) && state.uid < this._maxUid) {
						window.history.forward();
					}
				}
			}, {
				key: '_pushOrReplaceState',
				value: function _pushOrReplaceState(destination) {
					var forceReplace = arguments.length > 1 && arguments[1] !== undefined ?
						arguments[1] : false;
					var shouldReplace = forceReplace || !this._destination;
					var newState = {
						fingerprint: this.fingerprint,
						uid: shouldReplace ? this._uid : this._uid + 1,
						destination: destination
					};
					this._updateInternalState(destination, newState.uid);
					if (shouldReplace) {
						window.history.replaceState(newState, '', document.URL);
					} else {
						this._maxUid = this._uid;
						window.history.pushState(newState, '', document.URL);
					}
				}
			}, {
				key: '_tryPushCurrentPosition',
				value: function _tryPushCurrentPosition() {
					var temporary = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : false;
					if (!this._position) {
						return;
					}
					var position = this._position;
					if (temporary) {
						position = (0,
							_ui_utils.cloneObj)(this._position);
						position.temporary = true;
					}
					if (!this._destination) {
						this._pushOrReplaceState(position);
						return;
					}
					if (this._destination.temporary) {
						this._pushOrReplaceState(position, true);
						return;
					}
					if (this._destination.hash === position.hash) {
						return;
					}
					if (!this._destination.page && (POSITION_UPDATED_THRESHOLD <= 0 || this
							._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)) {
						return;
					}
					var forceReplace = false;
					if (this._destination.page === position.first || this._destination
						.page === position.page) {
						if (this._destination.dest || !this._destination.first) {
							return;
						}
						forceReplace = true;
					}
					this._pushOrReplaceState(position, forceReplace);
				}
			}, {
				key: '_isValidState',
				value: function _isValidState(state) {
					if (!state) {
						return false;
					}
					if (state.fingerprint !== this.fingerprint) {
						return false;
					}
					if (!Number.isInteger(state.uid) || state.uid < 0) {
						return false;
					}
					if (state.destination === null || _typeof(state.destination) !==
						'object') {
						return false;
					}
					return true;
				}
			}, {
				key: '_updateInternalState',
				value: function _updateInternalState(destination, uid) {
					var removeTemporary = arguments.length > 2 && arguments[2] !==
						undefined ? arguments[2] : false;
					if (this._updateViewareaTimeout) {
						clearTimeout(this._updateViewareaTimeout);
						this._updateViewareaTimeout = null;
					}
					if (removeTemporary && destination && destination.temporary) {
						delete destination.temporary;
					}
					this._destination = destination;
					this._uid = uid;
					this._numPositionUpdates = 0;
				}
			}, {
				key: '_updateViewarea',
				value: function _updateViewarea(_ref3) {
					var _this3 = this;
					var location = _ref3.location;
					if (this._updateViewareaTimeout) {
						clearTimeout(this._updateViewareaTimeout);
						this._updateViewareaTimeout = null;
					}
					this._position = {
						hash: this._isViewerInPresentationMode ? 'page=' + location
							.pageNumber : location.pdfOpenParams.substring(1),
						page: this.linkService.page,
						first: location.pageNumber,
						rotation: location.rotation
					};
					if (this._popStateInProgress) {
						return;
					}
					if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded && this
						._destination && !this._destination.page) {
						this._numPositionUpdates++;
					}
					if (UPDATE_VIEWAREA_TIMEOUT > 0) {
						this._updateViewareaTimeout = setTimeout(function() {
							if (!_this3._popStateInProgress) {
								_this3._tryPushCurrentPosition(true);
							}
							_this3._updateViewareaTimeout = null;
						}, UPDATE_VIEWAREA_TIMEOUT);
					}
				}
			}, {
				key: '_popState',
				value: function _popState(_ref4) {
					var _this4 = this;
					var state = _ref4.state;
					var newHash = getCurrentHash(),
						hashChanged = this._currentHash !== newHash;
					this._currentHash = newHash;
					if (!state || false) {
						this._uid++;
						var _parseCurrentHash2 = parseCurrentHash(this.linkService),
							hash = _parseCurrentHash2.hash,
							page = _parseCurrentHash2.page,
							rotation = _parseCurrentHash2.rotation;
						this._pushOrReplaceState({
							hash: hash,
							page: page,
							rotation: rotation
						}, true);
						return;
					}
					if (!this._isValidState(state)) {
						return;
					}
					this._popStateInProgress = true;
					if (hashChanged) {
						this._blockHashChange++;
						(0,
							_ui_utils.waitOnEventOrTimeout)({
							target: window,
							name: 'hashchange',
							delay: HASH_CHANGE_TIMEOUT
						}).then(function() {
							_this4._blockHashChange--;
						});
					}
					var destination = state.destination;
					this._updateInternalState(destination, state.uid, true);
					if ((0,
							_ui_utils.isValidRotation)(destination.rotation)) {
						this.linkService.rotation = destination.rotation;
					}
					if (destination.dest) {
						this.linkService.navigateTo(destination.dest);
					} else if (destination.hash) {
						this.linkService.setHash(destination.hash);
					} else if (destination.page) {
						this.linkService.page = destination.page;
					}
					Promise.resolve().then(function() {
						_this4._popStateInProgress = false;
					});
				}
			}, {
				key: '_bindEvents',
				value: function _bindEvents() {
					var _this5 = this;
					var _boundEvents = this._boundEvents,
						eventBus = this.eventBus;
					_boundEvents.updateViewarea = this._updateViewarea.bind(this);
					_boundEvents.popState = this._popState.bind(this);
					_boundEvents.pageHide = function(evt) {
						if (!_this5._destination) {
							_this5._tryPushCurrentPosition();
						}
					};
					eventBus.on('updateviewarea', _boundEvents.updateViewarea);
					window.addEventListener('popstate', _boundEvents.popState);
					window.addEventListener('pagehide', _boundEvents.pageHide);
				}
			}, {
				key: 'popStateInProgress',
				get: function get() {
					return this.initialized && (this._popStateInProgress || this
						._blockHashChange > 0);
				}
			}]);
			return PDFHistory;
		}();

		function isDestHashesEqual(destHash, pushHash) {
			if (typeof destHash !== 'string' || typeof pushHash !== 'string') {
				return false;
			}
			if (destHash === pushHash) {
				return true;
			}
			var _parseQueryString = (0,
					_ui_utils.parseQueryString)(destHash),
				nameddest = _parseQueryString.nameddest;
			if (nameddest === pushHash) {
				return true;
			}
			return false;
		}

		function isDestArraysEqual(firstDest, secondDest) {
			function isEntryEqual(first, second) {
				if ((typeof first === 'undefined' ? 'undefined' : _typeof(first)) !== (typeof second ===
						'undefined' ? 'undefined' : _typeof(second))) {
					return false;
				}
				if (first instanceof Array || second instanceof Array) {
					return false;
				}
				if (first !== null && (typeof first === 'undefined' ? 'undefined' : _typeof(first)) ===
					'object' && second !== null) {
					if (Object.keys(first).length !== Object.keys(second).length) {
						return false;
					}
					for (var key in first) {
						if (!isEntryEqual(first[key], second[key])) {
							return false;
						}
					}
					return true;
				}
				return first === second || Number.isNaN(first) && Number.isNaN(second);
			}
			if (!(firstDest instanceof Array && secondDest instanceof Array)) {
				return false;
			}
			if (firstDest.length !== secondDest.length) {
				return false;
			}
			for (var i = 0, ii = firstDest.length; i < ii; i++) {
				if (!isEntryEqual(firstDest[i], secondDest[i])) {
					return false;
				}
			}
			return true;
		}
		exports.PDFHistory = PDFHistory;
		exports.isDestHashesEqual = isDestHashesEqual;
		exports.isDestArraysEqual = isDestArraysEqual;
	}), /* 17 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFOutlineViewer = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var DEFAULT_TITLE = '\u2013';
		var PDFOutlineViewer = function() {
			function PDFOutlineViewer(_ref) {
				var container = _ref.container,
					linkService = _ref.linkService,
					eventBus = _ref.eventBus;
				_classCallCheck(this, PDFOutlineViewer);
				this.container = container;
				this.linkService = linkService;
				this.eventBus = eventBus;
				this.reset();
			}
			_createClass(PDFOutlineViewer, [{
				key: 'reset',
				value: function reset() {
					this.outline = null;
					this.lastToggleIsShow = true;
					this.container.textContent = '';
					this.container.classList.remove('outlineWithDeepNesting');
				}
			}, {
				key: '_dispatchEvent',
				value: function _dispatchEvent(outlineCount) {
					this.eventBus.dispatch('outlineloaded', {
						source: this,
						outlineCount: outlineCount
					});
				}
			}, {
				key: '_bindLink',
				value: function _bindLink(element, item) {
					var _this = this;
					if (item.url) {
						(0,
							_pdfjsLib.addLinkAttributes)(element, {
							url: item.url,
							target: item.newWindow ? _pdfjsLib.PDFJS.LinkTarget.BLANK :
								undefined
						});
						return;
					}
					var destination = item.dest;
					element.href = this.linkService.getDestinationHash(destination);
					element.onclick = function() {
						if (destination) {
							_this.linkService.navigateTo(destination);
						}
						return false;
					};
				}
			}, {
				key: '_setStyles',
				value: function _setStyles(element, item) {
					var styleStr = '';
					if (item.bold) {
						styleStr += 'font-weight: bold;';
					}
					if (item.italic) {
						styleStr += 'font-style: italic;';
					}
					if (styleStr) {
						element.setAttribute('style', styleStr);
					}
				}
			}, {
				key: '_addToggleButton',
				value: function _addToggleButton(div) {
					var _this2 = this;
					var toggler = document.createElement('div');
					toggler.className = 'outlineItemToggler';
					toggler.onclick = function(evt) {
						evt.stopPropagation();
						toggler.classList.toggle('outlineItemsHidden');
						if (evt.shiftKey) {
							var shouldShowAll = !toggler.classList.contains(
								'outlineItemsHidden');
							_this2._toggleOutlineItem(div, shouldShowAll);
						}
					};
					div.insertBefore(toggler, div.firstChild);
				}
			}, {
				key: '_toggleOutlineItem',
				value: function _toggleOutlineItem(root, show) {
					this.lastToggleIsShow = show;
					var togglers = root.querySelectorAll('.outlineItemToggler');
					for (var i = 0, ii = togglers.length; i < ii; ++i) {
						togglers[i].classList[show ? 'remove' : 'add'](
						'outlineItemsHidden');
					}
				}
			}, {
				key: 'toggleOutlineTree',
				value: function toggleOutlineTree() {
					if (!this.outline) {
						return;
					}
					this._toggleOutlineItem(this.container, !this.lastToggleIsShow);
				}
			}, {
				key: 'render',
				value: function render(_ref2) {
					var outline = _ref2.outline;
					var outlineCount = 0;
					if (this.outline) {
						this.reset();
					}
					this.outline = outline || null;
					if (!outline) {
						this._dispatchEvent(outlineCount);
						return;
					}
					var fragment = document.createDocumentFragment();
					var queue = [{
						parent: fragment,
						items: this.outline
					}];
					var hasAnyNesting = false;
					while (queue.length > 0) {
						var levelData = queue.shift();
						for (var i = 0, len = levelData.items.length; i < len; i++) {
							var item = levelData.items[i];
							var div = document.createElement('div');
							div.className = 'outlineItem';
							var element = document.createElement('a');
							this._bindLink(element, item);
							this._setStyles(element, item);
							element.textContent = (0,
									_pdfjsLib.removeNullCharacters)(item.title) ||
								DEFAULT_TITLE;
							div.appendChild(element);
							if (item.items.length > 0) {
								hasAnyNesting = true;
								this._addToggleButton(div);
								var itemsDiv = document.createElement('div');
								itemsDiv.className = 'outlineItems';
								div.appendChild(itemsDiv);
								queue.push({
									parent: itemsDiv,
									items: item.items
								});
							}
							levelData.parent.appendChild(div);
							outlineCount++;
						}
					}
					if (hasAnyNesting) {
						this.container.classList.add('outlineWithDeepNesting');
					}
					this.container.appendChild(fragment);
					this._dispatchEvent(outlineCount);
				}
			}]);
			return PDFOutlineViewer;
		}();
		exports.PDFOutlineViewer = PDFOutlineViewer;
	}), /* 18 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFPresentationMode = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS = 1500;
		var DELAY_BEFORE_HIDING_CONTROLS = 3000;
		var ACTIVE_SELECTOR = 'pdfPresentationMode';
		var CONTROLS_SELECTOR = 'pdfPresentationModeControls';
		var MOUSE_SCROLL_COOLDOWN_TIME = 50;
		var PAGE_SWITCH_THRESHOLD = 0.1;
		var SWIPE_MIN_DISTANCE_THRESHOLD = 50;
		var SWIPE_ANGLE_THRESHOLD = Math.PI / 6;
		var PDFPresentationMode = function() {
			function PDFPresentationMode(_ref) {
				var _this = this;
				var container = _ref.container,
					_ref$viewer = _ref.viewer,
					viewer = _ref$viewer === undefined ? null : _ref$viewer,
					pdfViewer = _ref.pdfViewer,
					eventBus = _ref.eventBus,
					_ref$contextMenuItems = _ref.contextMenuItems,
					contextMenuItems = _ref$contextMenuItems === undefined ? null : _ref$contextMenuItems;
				_classCallCheck(this, PDFPresentationMode);
				this.container = container;
				this.viewer = viewer || container.firstElementChild;
				this.pdfViewer = pdfViewer;
				this.eventBus = eventBus;
				this.active = false;
				this.args = null;
				this.contextMenuOpen = false;
				this.mouseScrollTimeStamp = 0;
				this.mouseScrollDelta = 0;
				this.touchSwipeState = null;
				if (contextMenuItems) {
					contextMenuItems.contextFirstPage.addEventListener('click', function() {
						_this.contextMenuOpen = false;
						_this.eventBus.dispatch('firstpage');
					});
					contextMenuItems.contextLastPage.addEventListener('click', function() {
						_this.contextMenuOpen = false;
						_this.eventBus.dispatch('lastpage');
					});
					contextMenuItems.contextPageRotateCw.addEventListener('click', function() {
						_this.contextMenuOpen = false;
						_this.eventBus.dispatch('rotatecw');
					});
					contextMenuItems.contextPageRotateCcw.addEventListener('click', function() {
						_this.contextMenuOpen = false;
						_this.eventBus.dispatch('rotateccw');
					});
				}
			}
			_createClass(PDFPresentationMode, [{
				key: 'request',
				value: function request() {
					if (this.switchInProgress || this.active || !this.viewer
					.hasChildNodes()) {
						return false;
					}
					this._addFullscreenChangeListeners();
					this._setSwitchInProgress();
					this._notifyStateChange();
					if (this.container.requestFullscreen) {
						this.container.requestFullscreen();
					} else if (this.container.mozRequestFullScreen) {
						this.container.mozRequestFullScreen();
					} else if (this.container.webkitRequestFullscreen) {
						this.container.webkitRequestFullscreen(Element
						.ALLOW_KEYBOARD_INPUT);
					} else if (this.container.msRequestFullscreen) {
						this.container.msRequestFullscreen();
					} else {
						return false;
					}
					this.args = {
						page: this.pdfViewer.currentPageNumber,
						previousScale: this.pdfViewer.currentScaleValue
					};
					return true;
				}
			}, {
				key: '_mouseWheel',
				value: function _mouseWheel(evt) {
					if (!this.active) {
						return;
					}
					evt.preventDefault();
					var delta = (0,
						_ui_utils.normalizeWheelEventDelta)(evt);
					var currentTime = new Date().getTime();
					var storedTime = this.mouseScrollTimeStamp;
					if (currentTime > storedTime && currentTime - storedTime <
						MOUSE_SCROLL_COOLDOWN_TIME) {
						return;
					}
					if (this.mouseScrollDelta > 0 && delta < 0 || this.mouseScrollDelta <
						0 && delta > 0) {
						this._resetMouseScrollState();
					}
					this.mouseScrollDelta += delta;
					if (Math.abs(this.mouseScrollDelta) >= PAGE_SWITCH_THRESHOLD) {
						var totalDelta = this.mouseScrollDelta;
						this._resetMouseScrollState();
						var success = totalDelta > 0 ? this._goToPreviousPage() : this
							._goToNextPage();
						if (success) {
							this.mouseScrollTimeStamp = currentTime;
						}
					}
				}
			}, {
				key: '_goToPreviousPage',
				value: function _goToPreviousPage() {
					var page = this.pdfViewer.currentPageNumber;
					if (page <= 1) {
						return false;
					}
					this.pdfViewer.currentPageNumber = page - 1;
					return true;
				}
			}, {
				key: '_goToNextPage',
				value: function _goToNextPage() {
					var page = this.pdfViewer.currentPageNumber;
					if (page >= this.pdfViewer.pagesCount) {
						return false;
					}
					this.pdfViewer.currentPageNumber = page + 1;
					return true;
				}
			}, {
				key: '_notifyStateChange',
				value: function _notifyStateChange() {
					this.eventBus.dispatch('presentationmodechanged', {
						source: this,
						active: this.active,
						switchInProgress: !!this.switchInProgress
					});
				}
			}, {
				key: '_setSwitchInProgress',
				value: function _setSwitchInProgress() {
					var _this2 = this;
					if (this.switchInProgress) {
						clearTimeout(this.switchInProgress);
					}
					this.switchInProgress = setTimeout(function() {
						_this2._removeFullscreenChangeListeners();
						delete _this2.switchInProgress;
						_this2._notifyStateChange();
					}, DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS);
				}
			}, {
				key: '_resetSwitchInProgress',
				value: function _resetSwitchInProgress() {
					if (this.switchInProgress) {
						clearTimeout(this.switchInProgress);
						delete this.switchInProgress;
					}
				}
			}, {
				key: '_enter',
				value: function _enter() {
					var _this3 = this;
					this.active = true;
					this._resetSwitchInProgress();
					this._notifyStateChange();
					this.container.classList.add(ACTIVE_SELECTOR);
					setTimeout(function() {
						_this3.pdfViewer.currentPageNumber = _this3.args.page;
						_this3.pdfViewer.currentScaleValue = 'page-fit';
					}, 0);
					this._addWindowListeners();
					this._showControls();
					this.contextMenuOpen = false;
					this.container.setAttribute('contextmenu', 'viewerContextMenu');
					window.getSelection().removeAllRanges();
				}
			}, {
				key: '_exit',
				value: function _exit() {
					var _this4 = this;
					var page = this.pdfViewer.currentPageNumber;
					this.container.classList.remove(ACTIVE_SELECTOR);
					setTimeout(function() {
						_this4.active = false;
						_this4._removeFullscreenChangeListeners();
						_this4._notifyStateChange();
						_this4.pdfViewer.currentScaleValue = _this4.args
							.previousScale;
						_this4.pdfViewer.currentPageNumber = page;
						_this4.args = null;
					}, 0);
					this._removeWindowListeners();
					this._hideControls();
					this._resetMouseScrollState();
					this.container.removeAttribute('contextmenu');
					this.contextMenuOpen = false;
				}
			}, {
				key: '_mouseDown',
				value: function _mouseDown(evt) {
					if (this.contextMenuOpen) {
						this.contextMenuOpen = false;
						evt.preventDefault();
						return;
					}
					if (evt.button === 0) {
						var isInternalLink = evt.target.href && evt.target.classList
							.contains('internalLink');
						if (!isInternalLink) {
							evt.preventDefault();
							if (evt.shiftKey) {
								this._goToPreviousPage();
							} else {
								this._goToNextPage();
							}
						}
					}
				}
			}, {
				key: '_contextMenu',
				value: function _contextMenu() {
					this.contextMenuOpen = true;
				}
			}, {
				key: '_showControls',
				value: function _showControls() {
					var _this5 = this;
					if (this.controlsTimeout) {
						clearTimeout(this.controlsTimeout);
					} else {
						this.container.classList.add(CONTROLS_SELECTOR);
					}
					this.controlsTimeout = setTimeout(function() {
						_this5.container.classList.remove(CONTROLS_SELECTOR);
						delete _this5.controlsTimeout;
					}, DELAY_BEFORE_HIDING_CONTROLS);
				}
			}, {
				key: '_hideControls',
				value: function _hideControls() {
					if (!this.controlsTimeout) {
						return;
					}
					clearTimeout(this.controlsTimeout);
					this.container.classList.remove(CONTROLS_SELECTOR);
					delete this.controlsTimeout;
				}
			}, {
				key: '_resetMouseScrollState',
				value: function _resetMouseScrollState() {
					this.mouseScrollTimeStamp = 0;
					this.mouseScrollDelta = 0;
				}
			}, {
				key: '_touchSwipe',
				value: function _touchSwipe(evt) {
					if (!this.active) {
						return;
					}
					if (evt.touches.length > 1) {
						this.touchSwipeState = null;
						return;
					}
					switch (evt.type) {
						case 'touchstart':
							this.touchSwipeState = {
								startX: evt.touches[0].pageX,
								startY: evt.touches[0].pageY,
								endX: evt.touches[0].pageX,
								endY: evt.touches[0].pageY
							};
							break;
						case 'touchmove':
							if (this.touchSwipeState === null) {
								return;
							}
							this.touchSwipeState.endX = evt.touches[0].pageX;
							this.touchSwipeState.endY = evt.touches[0].pageY;
							evt.preventDefault();
							break;
						case 'touchend':
							if (this.touchSwipeState === null) {
								return;
							}
							var delta = 0;
							var dx = this.touchSwipeState.endX - this.touchSwipeState
							.startX;
							var dy = this.touchSwipeState.endY - this.touchSwipeState
							.startY;
							var absAngle = Math.abs(Math.atan2(dy, dx));
							if (Math.abs(dx) > SWIPE_MIN_DISTANCE_THRESHOLD && (absAngle <=
									SWIPE_ANGLE_THRESHOLD || absAngle >= Math.PI -
									SWIPE_ANGLE_THRESHOLD)) {
								delta = dx;
							} else if (Math.abs(dy) > SWIPE_MIN_DISTANCE_THRESHOLD && Math
								.abs(absAngle - Math.PI / 2) <= SWIPE_ANGLE_THRESHOLD) {
								delta = dy;
							}
							if (delta > 0) {
								this._goToPreviousPage();
							} else if (delta < 0) {
								this._goToNextPage();
							}
							break;
					}
				}
			}, {
				key: '_addWindowListeners',
				value: function _addWindowListeners() {
					this.showControlsBind = this._showControls.bind(this);
					this.mouseDownBind = this._mouseDown.bind(this);
					this.mouseWheelBind = this._mouseWheel.bind(this);
					this.resetMouseScrollStateBind = this._resetMouseScrollState.bind(this);
					this.contextMenuBind = this._contextMenu.bind(this);
					this.touchSwipeBind = this._touchSwipe.bind(this);
					window.addEventListener('mousemove', this.showControlsBind);
					window.addEventListener('mousedown', this.mouseDownBind);
					window.addEventListener('wheel', this.mouseWheelBind);
					window.addEventListener('keydown', this.resetMouseScrollStateBind);
					window.addEventListener('contextmenu', this.contextMenuBind);
					window.addEventListener('touchstart', this.touchSwipeBind);
					window.addEventListener('touchmove', this.touchSwipeBind);
					window.addEventListener('touchend', this.touchSwipeBind);
				}
			}, {
				key: '_removeWindowListeners',
				value: function _removeWindowListeners() {
					window.removeEventListener('mousemove', this.showControlsBind);
					window.removeEventListener('mousedown', this.mouseDownBind);
					window.removeEventListener('wheel', this.mouseWheelBind);
					window.removeEventListener('keydown', this.resetMouseScrollStateBind);
					window.removeEventListener('contextmenu', this.contextMenuBind);
					window.removeEventListener('touchstart', this.touchSwipeBind);
					window.removeEventListener('touchmove', this.touchSwipeBind);
					window.removeEventListener('touchend', this.touchSwipeBind);
					delete this.showControlsBind;
					delete this.mouseDownBind;
					delete this.mouseWheelBind;
					delete this.resetMouseScrollStateBind;
					delete this.contextMenuBind;
					delete this.touchSwipeBind;
				}
			}, {
				key: '_fullscreenChange',
				value: function _fullscreenChange() {
					if (this.isFullscreen) {
						this._enter();
					} else {
						this._exit();
					}
				}
			}, {
				key: '_addFullscreenChangeListeners',
				value: function _addFullscreenChangeListeners() {
					this.fullscreenChangeBind = this._fullscreenChange.bind(this);
					window.addEventListener('fullscreenchange', this.fullscreenChangeBind);
					window.addEventListener('mozfullscreenchange', this
						.fullscreenChangeBind);
					window.addEventListener('webkitfullscreenchange', this
						.fullscreenChangeBind);
					window.addEventListener('MSFullscreenChange', this
					.fullscreenChangeBind);
				}
			}, {
				key: '_removeFullscreenChangeListeners',
				value: function _removeFullscreenChangeListeners() {
					window.removeEventListener('fullscreenchange', this
						.fullscreenChangeBind);
					window.removeEventListener('mozfullscreenchange', this
						.fullscreenChangeBind);
					window.removeEventListener('webkitfullscreenchange', this
						.fullscreenChangeBind);
					window.removeEventListener('MSFullscreenChange', this
						.fullscreenChangeBind);
					delete this.fullscreenChangeBind;
				}
			}, {
				key: 'isFullscreen',
				get: function get() {
					return !!(document.fullscreenElement || document.mozFullScreen ||
						document.webkitIsFullScreen || document.msFullscreenElement);
				}
			}]);
			return PDFPresentationMode;
		}();
		exports.PDFPresentationMode = PDFPresentationMode;
	}), /* 19 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFThumbnailViewer = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);
		var _pdf_thumbnail_view = __webpack_require__(20);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var THUMBNAIL_SCROLL_MARGIN = -19;
		var PDFThumbnailViewer = function() {
			function PDFThumbnailViewer(_ref) {
				var container = _ref.container,
					linkService = _ref.linkService,
					renderingQueue = _ref.renderingQueue,
					_ref$l10n = _ref.l10n,
					l10n = _ref$l10n === undefined ? _ui_utils.NullL10n : _ref$l10n;
				_classCallCheck(this, PDFThumbnailViewer);
				this.container = container;
				this.linkService = linkService;
				this.renderingQueue = renderingQueue;
				this.l10n = l10n;
				this.scroll = (0,
					_ui_utils.watchScroll)(this.container, this._scrollUpdated.bind(this));
				this._resetView();
			}
			_createClass(PDFThumbnailViewer, [{
				key: '_scrollUpdated',
				value: function _scrollUpdated() {
					this.renderingQueue.renderHighestPriority();
				}
			}, {
				key: 'getThumbnail',
				value: function getThumbnail(index) {
					return this._thumbnails[index];
				}
			}, {
				key: '_getVisibleThumbs',
				value: function _getVisibleThumbs() {
					return (0,
						_ui_utils.getVisibleElements)(this.container, this._thumbnails);
				}
			}, {
				key: 'scrollThumbnailIntoView',
				value: function scrollThumbnailIntoView(page) {
					var selected = document.querySelector('.thumbnail.selected');
					if (selected) {
						selected.classList.remove('selected');
					}
					var thumbnail = document.querySelector(
						'div.thumbnail[data-page-number="' + page + '"]');
					if (thumbnail) {
						thumbnail.classList.add('selected');
					}
					var visibleThumbs = this._getVisibleThumbs();
					var numVisibleThumbs = visibleThumbs.views.length;
					if (numVisibleThumbs > 0) {
						var first = visibleThumbs.first.id;
						var last = numVisibleThumbs > 1 ? visibleThumbs.last.id : first;
						if (page <= first || page >= last) {
							(0,
								_ui_utils.scrollIntoView)(thumbnail, {
								top: THUMBNAIL_SCROLL_MARGIN
							});
						}
					}
				}
			}, {
				key: 'cleanup',
				value: function cleanup() {
					_pdf_thumbnail_view.PDFThumbnailView.cleanup();
				}
			}, {
				key: '_resetView',
				value: function _resetView() {
					this._thumbnails = [];
					this._pageLabels = null;
					this._pagesRotation = 0;
					this._pagesRequests = [];
					this.container.textContent = '';
				}
			}, {
				key: 'setDocument',
				value: function setDocument(pdfDocument) {
					var _this = this;
					if (this.pdfDocument) {
						this._cancelRendering();
						this._resetView();
					}
					this.pdfDocument = pdfDocument;
					if (!pdfDocument) {
						return;
					}
					pdfDocument.getPage(1).then(function(firstPage) {
						var pagesCount = pdfDocument.numPages;
						var viewport = firstPage.getViewport(1.0);
						for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) {
							var thumbnail = new _pdf_thumbnail_view
								.PDFThumbnailView({
									container: _this.container,
									id: pageNum,
									defaultViewport: viewport.clone(),
									linkService: _this.linkService,
									renderingQueue: _this.renderingQueue,
									disableCanvasToImageConversion: false,
									l10n: _this.l10n
								});
							_this._thumbnails.push(thumbnail);
						}
					}).catch(function(reason) {
						console.error('Unable to initialize thumbnail viewer',
							reason);
					});
				}
			}, {
				key: '_cancelRendering',
				value: function _cancelRendering() {
					for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
						if (this._thumbnails[i]) {
							this._thumbnails[i].cancelRendering();
						}
					}
				}
			}, {
				key: 'setPageLabels',
				value: function setPageLabels(labels) {
					if (!this.pdfDocument) {
						return;
					}
					if (!labels) {
						this._pageLabels = null;
					} else if (!(labels instanceof Array && this.pdfDocument.numPages ===
							labels.length)) {
						this._pageLabels = null;
						console.error(
							'PDFThumbnailViewer_setPageLabels: Invalid page labels.');
					} else {
						this._pageLabels = labels;
					}
					for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
						var label = this._pageLabels && this._pageLabels[i];
						this._thumbnails[i].setPageLabel(label);
					}
				}
			}, {
				key: '_ensurePdfPageLoaded',
				value: function _ensurePdfPageLoaded(thumbView) {
					var _this2 = this;
					if (thumbView.pdfPage) {
						return Promise.resolve(thumbView.pdfPage);
					}
					var pageNumber = thumbView.id;
					if (this._pagesRequests[pageNumber]) {
						return this._pagesRequests[pageNumber];
					}
					var promise = this.pdfDocument.getPage(pageNumber).then(function(
						pdfPage) {
						thumbView.setPdfPage(pdfPage);
						_this2._pagesRequests[pageNumber] = null;
						return pdfPage;
					}).catch(function(reason) {
						console.error('Unable to get page for thumb view', reason);
						_this2._pagesRequests[pageNumber] = null;
					});
					this._pagesRequests[pageNumber] = promise;
					return promise;
				}
			}, {
				key: 'forceRendering',
				value: function forceRendering() {
					var _this3 = this;
					var visibleThumbs = this._getVisibleThumbs();
					var thumbView = this.renderingQueue.getHighestPriority(visibleThumbs,
						this._thumbnails, this.scroll.down);
					if (thumbView) {
						this._ensurePdfPageLoaded(thumbView).then(function() {
							_this3.renderingQueue.renderView(thumbView);
						});
						return true;
					}
					return false;
				}
			}, {
				key: 'pagesRotation',
				get: function get() {
					return this._pagesRotation;
				},
				set: function set(rotation) {
					if (!(0,
							_ui_utils.isValidRotation)(rotation)) {
						throw new Error('Invalid thumbnails rotation angle.');
					}
					if (!this.pdfDocument) {
						return;
					}
					if (this._pagesRotation === rotation) {
						return;
					}
					this._pagesRotation = rotation;
					for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
						this._thumbnails[i].update(rotation);
					}
				}
			}]);
			return PDFThumbnailViewer;
		}();
		exports.PDFThumbnailViewer = PDFThumbnailViewer;
	}), /* 20 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFThumbnailView = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdfjsLib = __webpack_require__(1);
		var _ui_utils = __webpack_require__(0);
		var _pdf_rendering_queue = __webpack_require__(3);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var MAX_NUM_SCALING_STEPS = 3;
		var THUMBNAIL_CANVAS_BORDER_WIDTH = 1;
		var THUMBNAIL_WIDTH = 98;
		var TempImageFactory = function TempImageFactoryClosure() {
			var tempCanvasCache = null;
			return {
				getCanvas: function getCanvas(width, height) {
					var tempCanvas = tempCanvasCache;
					if (!tempCanvas) {
						tempCanvas = document.createElement('canvas');
						tempCanvasCache = tempCanvas;
					}
					tempCanvas.width = width;
					tempCanvas.height = height;
					tempCanvas.mozOpaque = true;
					var ctx = tempCanvas.getContext('2d', {
						alpha: false
					});
					ctx.save();
					ctx.fillStyle = 'rgb(255, 255, 255)';
					ctx.fillRect(0, 0, width, height);
					ctx.restore();
					return tempCanvas;
				},
				destroyCanvas: function destroyCanvas() {
					var tempCanvas = tempCanvasCache;
					if (tempCanvas) {
						tempCanvas.width = 0;
						tempCanvas.height = 0;
					}
					tempCanvasCache = null;
				}
			};
		}();
		var PDFThumbnailView = function() {
			function PDFThumbnailView(_ref) {
				var container = _ref.container,
					id = _ref.id,
					defaultViewport = _ref.defaultViewport,
					linkService = _ref.linkService,
					renderingQueue = _ref.renderingQueue,
					_ref$disableCanvasToI = _ref.disableCanvasToImageConversion,
					disableCanvasToImageConversion = _ref$disableCanvasToI === undefined ? false :
					_ref$disableCanvasToI,
					_ref$l10n = _ref.l10n,
					l10n = _ref$l10n === undefined ? _ui_utils.NullL10n : _ref$l10n;
				_classCallCheck(this, PDFThumbnailView);
				this.id = id;
				this.renderingId = 'thumbnail' + id;
				this.pageLabel = null;
				this.pdfPage = null;
				this.rotation = 0;
				this.viewport = defaultViewport;
				this.pdfPageRotate = defaultViewport.rotation;
				this.linkService = linkService;
				this.renderingQueue = renderingQueue;
				this.renderTask = null;
				this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
				this.resume = null;
				this.disableCanvasToImageConversion = disableCanvasToImageConversion;
				this.pageWidth = this.viewport.width;
				this.pageHeight = this.viewport.height;
				this.pageRatio = this.pageWidth / this.pageHeight;
				this.canvasWidth = THUMBNAIL_WIDTH;
				this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
				this.scale = this.canvasWidth / this.pageWidth;
				this.l10n = l10n;
				var anchor = document.createElement('a');
				anchor.href = linkService.getAnchorUrl('#page=' + id);
				this.l10n.get('thumb_page_title', {
					page: id
				}, 'Page {{page}}').then(function(msg) {
					anchor.title = msg;
				});
				anchor.onclick = function() {
					linkService.page = id;
					return false;
				};
				this.anchor = anchor;
				var div = document.createElement('div');
				div.className = 'thumbnail';
				div.setAttribute('data-page-number', this.id);
				this.div = div;
				if (id === 1) {
					div.classList.add('selected');
				}
				var ring = document.createElement('div');
				ring.className = 'thumbnailSelectionRing';
				var borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
				ring.style.width = this.canvasWidth + borderAdjustment + 'px';
				ring.style.height = this.canvasHeight + borderAdjustment + 'px';
				this.ring = ring;
				div.appendChild(ring);
				anchor.appendChild(div);
				container.appendChild(anchor);
			}
			_createClass(PDFThumbnailView, [{
				key: 'setPdfPage',
				value: function setPdfPage(pdfPage) {
					this.pdfPage = pdfPage;
					this.pdfPageRotate = pdfPage.rotate;
					var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
					this.viewport = pdfPage.getViewport(1, totalRotation);
					this.reset();
				}
			}, {
				key: 'reset',
				value: function reset() {
					this.cancelRendering();
					this.pageWidth = this.viewport.width;
					this.pageHeight = this.viewport.height;
					this.pageRatio = this.pageWidth / this.pageHeight;
					this.canvasHeight = this.canvasWidth / this.pageRatio | 0;
					this.scale = this.canvasWidth / this.pageWidth;
					this.div.removeAttribute('data-loaded');
					var ring = this.ring;
					var childNodes = ring.childNodes;
					for (var i = childNodes.length - 1; i >= 0; i--) {
						ring.removeChild(childNodes[i]);
					}
					var borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
					ring.style.width = this.canvasWidth + borderAdjustment + 'px';
					ring.style.height = this.canvasHeight + borderAdjustment + 'px';
					if (this.canvas) {
						this.canvas.width = 0;
						this.canvas.height = 0;
						delete this.canvas;
					}
					if (this.image) {
						this.image.removeAttribute('src');
						delete this.image;
					}
				}
			}, {
				key: 'update',
				value: function update(rotation) {
					if (typeof rotation !== 'undefined') {
						this.rotation = rotation;
					}
					var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
					this.viewport = this.viewport.clone({
						scale: 1,
						rotation: totalRotation
					});
					this.reset();
				}
			}, {
				key: 'cancelRendering',
				value: function cancelRendering() {
					if (this.renderTask) {
						this.renderTask.cancel();
						this.renderTask = null;
					}
					this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
					this.resume = null;
				}
			}, {
				key: '_getPageDrawContext',
				value: function _getPageDrawContext() {
					var noCtxScale = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : false;
					var canvas = document.createElement('canvas');
					this.canvas = canvas;
					canvas.mozOpaque = true;
					var ctx = canvas.getContext('2d', {
						alpha: false
					});
					var outputScale = (0,
						_ui_utils.getOutputScale)(ctx);
					canvas.width = this.canvasWidth * outputScale.sx | 0;
					canvas.height = this.canvasHeight * outputScale.sy | 0;
					canvas.style.width = this.canvasWidth + 'px';
					canvas.style.height = this.canvasHeight + 'px';
					if (!noCtxScale && outputScale.scaled) {
						ctx.scale(outputScale.sx, outputScale.sy);
					}
					return ctx;
				}
			}, {
				key: '_convertCanvasToImage',
				value: function _convertCanvasToImage() {
					var _this = this;
					if (!this.canvas) {
						return;
					}
					if (this.renderingState !== _pdf_rendering_queue.RenderingStates
						.FINISHED) {
						return;
					}
					var id = this.renderingId;
					var className = 'thumbnailImage';
					if (this.disableCanvasToImageConversion) {
						this.canvas.id = id;
						this.canvas.className = className;
						this.l10n.get('thumb_page_canvas', {
							page: this.pageId
						}, 'Thumbnail of Page {{page}}').then(function(msg) {
							_this.canvas.setAttribute('aria-label', msg);
						});
						this.div.setAttribute('data-loaded', true);
						this.ring.appendChild(this.canvas);
						return;
					}
					var image = document.createElement('img');
					image.id = id;
					image.className = className;
					this.l10n.get('thumb_page_canvas', {
						page: this.pageId
					}, 'Thumbnail of Page {{page}}').then(function(msg) {
						image.setAttribute('aria-label', msg);
					});
					image.style.width = this.canvasWidth + 'px';
					image.style.height = this.canvasHeight + 'px';
					image.src = this.canvas.toDataURL();
					this.image = image;
					this.div.setAttribute('data-loaded', true);
					this.ring.appendChild(image);
					this.canvas.width = 0;
					this.canvas.height = 0;
					delete this.canvas;
				}
			}, {
				key: 'draw',
				value: function draw() {
					var _this2 = this;
					if (this.renderingState !== _pdf_rendering_queue.RenderingStates
						.INITIAL) {
						console.error('Must be in new state before drawing');
						return Promise.resolve(undefined);
					}
					this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
					var renderCapability = (0,
						_pdfjsLib.createPromiseCapability)();
					var finishRenderTask = function finishRenderTask(error) {
						if (renderTask === _this2.renderTask) {
							_this2.renderTask = null;
						}
						if (error === 'cancelled' || error instanceof _pdfjsLib
							.RenderingCancelledException) {
							renderCapability.resolve(undefined);
							return;
						}
						_this2.renderingState = _pdf_rendering_queue.RenderingStates
							.FINISHED;
						_this2._convertCanvasToImage();
						if (!error) {
							renderCapability.resolve(undefined);
						} else {
							renderCapability.reject(error);
						}
					};
					var ctx = this._getPageDrawContext();
					var drawViewport = this.viewport.clone({
						scale: this.scale
					});
					var renderContinueCallback = function renderContinueCallback(cont) {
						if (!_this2.renderingQueue.isHighestPriority(_this2)) {
							_this2.renderingState = _pdf_rendering_queue.RenderingStates
								.PAUSED;
							_this2.resume = function() {
								_this2.renderingState = _pdf_rendering_queue
									.RenderingStates.RUNNING;
								cont();
							};
							return;
						}
						cont();
					};
					var renderContext = {
						canvasContext: ctx,
						viewport: drawViewport
					};
					var renderTask = this.renderTask = this.pdfPage.render(renderContext);
					renderTask.onContinue = renderContinueCallback;
					renderTask.promise.then(function() {
						finishRenderTask(null);
					}, function(error) {
						finishRenderTask(error);
					});
					return renderCapability.promise;
				}
			}, {
				key: 'setImage',
				value: function setImage(pageView) {
					if (this.renderingState !== _pdf_rendering_queue.RenderingStates
						.INITIAL) {
						return;
					}
					var img = pageView.canvas;
					if (!img) {
						return;
					}
					if (!this.pdfPage) {
						this.setPdfPage(pageView.pdfPage);
					}
					this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
					var ctx = this._getPageDrawContext(true);
					var canvas = ctx.canvas;
					if (img.width <= 2 * canvas.width) {
						ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, canvas.width,
							canvas.height);
						this._convertCanvasToImage();
						return;
					}
					var reducedWidth = canvas.width << MAX_NUM_SCALING_STEPS;
					var reducedHeight = canvas.height << MAX_NUM_SCALING_STEPS;
					var reducedImage = TempImageFactory.getCanvas(reducedWidth,
						reducedHeight);
					var reducedImageCtx = reducedImage.getContext('2d');
					while (reducedWidth > img.width || reducedHeight > img.height) {
						reducedWidth >>= 1;
						reducedHeight >>= 1;
					}
					reducedImageCtx.drawImage(img, 0, 0, img.width, img.height, 0, 0,
						reducedWidth, reducedHeight);
					while (reducedWidth > 2 * canvas.width) {
						reducedImageCtx.drawImage(reducedImage, 0, 0, reducedWidth,
							reducedHeight, 0, 0, reducedWidth >> 1, reducedHeight >> 1);
						reducedWidth >>= 1;
						reducedHeight >>= 1;
					}
					ctx.drawImage(reducedImage, 0, 0, reducedWidth, reducedHeight, 0, 0,
						canvas.width, canvas.height);
					this._convertCanvasToImage();
				}
			}, {
				key: 'setPageLabel',
				value: function setPageLabel(label) {
					var _this3 = this;
					this.pageLabel = typeof label === 'string' ? label : null;
					this.l10n.get('thumb_page_title', {
						page: this.pageId
					}, 'Page {{page}}').then(function(msg) {
						_this3.anchor.title = msg;
					});
					if (this.renderingState !== _pdf_rendering_queue.RenderingStates
						.FINISHED) {
						return;
					}
					this.l10n.get('thumb_page_canvas', {
						page: this.pageId
					}, 'Thumbnail of Page {{page}}').then(function(ariaLabel) {
						if (_this3.image) {
							_this3.image.setAttribute('aria-label', ariaLabel);
						} else if (_this3.disableCanvasToImageConversion && _this3
							.canvas) {
							_this3.canvas.setAttribute('aria-label', ariaLabel);
						}
					});
				}
			}, {
				key: 'pageId',
				get: function get() {
					return this.pageLabel !== null ? this.pageLabel : this.id;
				}
			}], [{
				key: 'cleanup',
				value: function cleanup() {
					TempImageFactory.destroyCanvas();
				}
			}]);
			return PDFThumbnailView;
		}();
		exports.PDFThumbnailView = PDFThumbnailView;
	}), /* 21 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFViewer = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);
		var _base_viewer = __webpack_require__(22);
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}

		function _possibleConstructorReturn(self, call) {
			if (!self) {
				throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
			}
			return call && (typeof call === "object" || typeof call === "function") ? call : self;
		}

		function _inherits(subClass, superClass) {
			if (typeof superClass !== "function" && superClass !== null) {
				throw new TypeError("Super expression must either be null or a function, not " +
					typeof superClass);
			}
			subClass.prototype = Object.create(superClass && superClass.prototype, {
				constructor: {
					value: subClass,
					enumerable: false,
					writable: true,
					configurable: true
				}
			});
			if (superClass)
				Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ =
				superClass;
		}
		var PDFViewer = function(_BaseViewer) {
			_inherits(PDFViewer, _BaseViewer);

			function PDFViewer() {
				_classCallCheck(this, PDFViewer);
				return _possibleConstructorReturn(this, (PDFViewer.__proto__ || Object.getPrototypeOf(
					PDFViewer)).apply(this, arguments));
			}
			_createClass(PDFViewer, [{
				key: '_scrollIntoView',
				value: function _scrollIntoView(_ref) {
					var pageDiv = _ref.pageDiv,
						_ref$pageSpot = _ref.pageSpot,
						pageSpot = _ref$pageSpot === undefined ? null : _ref$pageSpot;
					(0,
						_ui_utils.scrollIntoView)(pageDiv, pageSpot);
				}
			}, {
				key: '_getVisiblePages',
				value: function _getVisiblePages() {
					if (!this.isInPresentationMode) {
						return (0,
							_ui_utils.getVisibleElements)(this.container, this._pages,
							true);
					}
					var currentPage = this._pages[this._currentPageNumber - 1];
					var visible = [{
						id: currentPage.id,
						view: currentPage
					}];
					return {
						first: currentPage,
						last: currentPage,
						views: visible
					};
				}
			}, {
				key: 'update',
				value: function update() {
					var visible = this._getVisiblePages();
					var visiblePages = visible.views,
						numVisiblePages = visiblePages.length;
					if (numVisiblePages === 0) {
						return;
					}
					this._resizeBuffer(numVisiblePages);
					this.renderingQueue.renderHighestPriority(visible);
					var currentId = this._currentPageNumber;
					var stillFullyVisible = false;
					for (var i = 0; i < numVisiblePages; ++i) {
						var page = visiblePages[i];
						if (page.percent < 100) {
							break;
						}
						if (page.id === currentId) {
							stillFullyVisible = true;
							break;
						}
					}
					if (!stillFullyVisible) {
						currentId = visiblePages[0].id;
					}
					if (!this.isInPresentationMode) {
						this._setCurrentPageNumber(currentId);
					}
					this._updateLocation(visible.first);
					this.eventBus.dispatch('updateviewarea', {
						source: this,
						location: this._location
					});
				}
			}, {
				key: '_setDocumentViewerElement',
				get: function get() {
					return (0,
						_pdfjsLib.shadow)(this, '_setDocumentViewerElement', this
						.viewer);
				}
			}]);
			return PDFViewer;
		}(_base_viewer.BaseViewer);
		exports.PDFViewer = PDFViewer;
	}), /* 22 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.BaseViewer = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdfjsLib = __webpack_require__(1);
		var _ui_utils = __webpack_require__(0);
		var _pdf_rendering_queue = __webpack_require__(3);
		var _annotation_layer_builder = __webpack_require__(23);
		var _dom_events = __webpack_require__(2);
		var _pdf_page_view = __webpack_require__(24);
		var _pdf_link_service = __webpack_require__(5);
		var _text_layer_builder = __webpack_require__(25);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var DEFAULT_CACHE_SIZE = 10;

		function PDFPageViewBuffer(size) {
			var data = [];
			this.push = function(view) {
				var i = data.indexOf(view);
				if (i >= 0) {
					data.splice(i, 1);
				}
				data.push(view);
				if (data.length > size) {
					data.shift().destroy();
				}
			};
			this.resize = function(newSize) {
				size = newSize;
				while (data.length > size) {
					data.shift().destroy();
				}
			};
		}

		function isSameScale(oldScale, newScale) {
			if (newScale === oldScale) {
				return true;
			}
			if (Math.abs(newScale - oldScale) < 1e-15) {
				return true;
			}
			return false;
		}

		function isPortraitOrientation(size) {
			return size.width <= size.height;
		}
		var BaseViewer = function() {
			function BaseViewer(options) {
				_classCallCheck(this, BaseViewer);
				if (this.constructor === BaseViewer) {
					throw new Error('Cannot initialize BaseViewer.');
				}
				this._name = this.constructor.name;
				this.container = options.container;
				this.viewer = options.viewer || options.container.firstElementChild;
				this.eventBus = options.eventBus || (0,
					_dom_events.getGlobalEventBus)();
				this.linkService = options.linkService || new _pdf_link_service.SimpleLinkService();
				this.downloadManager = options.downloadManager || null;
				this.removePageBorders = options.removePageBorders || false;
				this.enhanceTextSelection = options.enhanceTextSelection || false;
				this.renderInteractiveForms = options.renderInteractiveForms || false;
				this.enablePrintAutoRotate = options.enablePrintAutoRotate || false;
				this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
				this.l10n = options.l10n || _ui_utils.NullL10n;
				this.defaultRenderingQueue = !options.renderingQueue;
				if (this.defaultRenderingQueue) {
					this.renderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
					this.renderingQueue.setViewer(this);
				} else {
					this.renderingQueue = options.renderingQueue;
				}
				this.scroll = (0,
					_ui_utils.watchScroll)(this.container, this._scrollUpdate.bind(this));
				this.presentationModeState = _ui_utils.PresentationModeState.UNKNOWN;
				this._resetView();
				if (this.removePageBorders) {
					this.viewer.classList.add('removePageBorders');
				}
			}
			_createClass(BaseViewer, [{
				key: 'getPageView',
				value: function getPageView(index) {
					return this._pages[index];
				}
			}, {
				key: '_setCurrentPageNumber',
				value: function _setCurrentPageNumber(val) {
					var resetCurrentPageView = arguments.length > 1 && arguments[1] !==
						undefined ? arguments[1] : false;
					if (this._currentPageNumber === val) {
						if (resetCurrentPageView) {
							this._resetCurrentPageView();
						}
						return;
					}
					if (!(0 < val && val <= this.pagesCount)) {
						console.error(this._name + '._setCurrentPageNumber: "' + val +
							'" is out of bounds.');
						return;
					}
					var arg = {
						source: this,
						pageNumber: val,
						pageLabel: this._pageLabels && this._pageLabels[val - 1]
					};
					this._currentPageNumber = val;
					this.eventBus.dispatch('pagechanging', arg);
					this.eventBus.dispatch('pagechange', arg);
					if (resetCurrentPageView) {
						this._resetCurrentPageView();
					}
				}
			}, {
				key: 'setDocument',
				value: function setDocument(pdfDocument) {
					var _this = this;
					if (this.pdfDocument) {
						this._cancelRendering();
						this._resetView();
					}
					this.pdfDocument = pdfDocument;
					if (!pdfDocument) {
						return;
					}
					var pagesCount = pdfDocument.numPages;
					var pagesCapability = (0,
						_pdfjsLib.createPromiseCapability)();
					this.pagesPromise = pagesCapability.promise;
					pagesCapability.promise.then(function() {
						_this._pageViewsReady = true;
						_this.eventBus.dispatch('pagesloaded', {
							source: _this,
							pagesCount: pagesCount
						});
					});
					var isOnePageRenderedResolved = false;
					var onePageRenderedCapability = (0,
						_pdfjsLib.createPromiseCapability)();
					this.onePageRendered = onePageRenderedCapability.promise;
					var bindOnAfterAndBeforeDraw = function bindOnAfterAndBeforeDraw(
						pageView) {
						pageView.onBeforeDraw = function() {
							_this._buffer.push(pageView);
						};
						pageView.onAfterDraw = function() {
							if (!isOnePageRenderedResolved) {
								isOnePageRenderedResolved = true;
								onePageRenderedCapability.resolve();
							}
						};
					};
					var firstPagePromise = pdfDocument.getPage(1);
					this.firstPagePromise = firstPagePromise;
					firstPagePromise.then(function(pdfPage) {
						var scale = _this.currentScale;
						var viewport = pdfPage.getViewport(scale * _ui_utils
							.CSS_UNITS);
						for (var pageNum = 1; pageNum <= pagesCount; ++pageNum) {
							var textLayerFactory = null;
							if (!_pdfjsLib.PDFJS.disableTextLayer) {
								textLayerFactory = _this;
							}
							var pageView = new _pdf_page_view.PDFPageView({
								container: _this._setDocumentViewerElement,
								eventBus: _this.eventBus,
								id: pageNum,
								scale: scale,
								defaultViewport: viewport.clone(),
								renderingQueue: _this.renderingQueue,
								textLayerFactory: textLayerFactory,
								annotationLayerFactory: _this,
								enhanceTextSelection: _this
									.enhanceTextSelection,
								renderInteractiveForms: _this
									.renderInteractiveForms,
								renderer: _this.renderer,
								l10n: _this.l10n
							});
							bindOnAfterAndBeforeDraw(pageView);
							_this._pages.push(pageView);
						}
						onePageRenderedCapability.promise.then(function() {
							if (_pdfjsLib.PDFJS.disableAutoFetch) {
								pagesCapability.resolve();
								return;
							}
							var getPagesLeft = pagesCount;
							var _loop = function _loop(_pageNum) {
								pdfDocument.getPage(_pageNum).then(
									function(pdfPage) {
										var pageView = _this._pages[
											_pageNum - 1];
										if (!pageView.pdfPage) {
											pageView.setPdfPage(
												pdfPage);
										}
										_this.linkService
											.cachePageRef(_pageNum,
												pdfPage.ref);
										if (--getPagesLeft === 0) {
											pagesCapability
											.resolve();
										}
									},
									function(reason) {
										console.error(
											'Unable to get page ' +
											_pageNum +
											' to initialize viewer',
											reason);
										if (--getPagesLeft === 0) {
											pagesCapability
											.resolve();
										}
									});
							};
							for (var _pageNum = 1; _pageNum <=
								pagesCount; ++_pageNum) {
								_loop(_pageNum);
							}
						});
						_this.eventBus.dispatch('pagesinit', {
							source: _this
						});
						if (_this.defaultRenderingQueue) {
							_this.update();
						}
						if (_this.findController) {
							_this.findController.resolveFirstPage();
						}
					}).catch(function(reason) {
						console.error('Unable to initialize viewer', reason);
					});
				}
			}, {
				key: 'setPageLabels',
				value: function setPageLabels(labels) {
					if (!this.pdfDocument) {
						return;
					}
					if (!labels) {
						this._pageLabels = null;
					} else if (!(labels instanceof Array && this.pdfDocument.numPages ===
							labels.length)) {
						this._pageLabels = null;
						console.error(this._name + '.setPageLabels: Invalid page labels.');
					} else {
						this._pageLabels = labels;
					}
					for (var i = 0, ii = this._pages.length; i < ii; i++) {
						var pageView = this._pages[i];
						var label = this._pageLabels && this._pageLabels[i];
						pageView.setPageLabel(label);
					}
				}
			}, {
				key: '_resetView',
				value: function _resetView() {
					this._pages = [];
					this._currentPageNumber = 1;
					this._currentScale = _ui_utils.UNKNOWN_SCALE;
					this._currentScaleValue = null;
					this._pageLabels = null;
					this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);
					this._location = null;
					this._pagesRotation = 0;
					this._pagesRequests = [];
					this._pageViewsReady = false;
					this.viewer.textContent = '';
				}
			}, {
				key: '_scrollUpdate',
				value: function _scrollUpdate() {
					if (this.pagesCount === 0) {
						return;
					}
					this.update();
				}
			}, {
				key: '_scrollIntoView',
				value: function _scrollIntoView(_ref) {
					var pageDiv = _ref.pageDiv,
						_ref$pageSpot = _ref.pageSpot,
						pageSpot = _ref$pageSpot === undefined ? null : _ref$pageSpot,
						_ref$pageNumber = _ref.pageNumber,
						pageNumber = _ref$pageNumber === undefined ? null : _ref$pageNumber;
					throw new Error('Not implemented: _scrollIntoView');
				}
			}, {
				key: '_setScaleDispatchEvent',
				value: function _setScaleDispatchEvent(newScale, newValue) {
					var preset = arguments.length > 2 && arguments[2] !== undefined ?
						arguments[2] : false;
					var arg = {
						source: this,
						scale: newScale,
						presetValue: preset ? newValue : undefined
					};
					this.eventBus.dispatch('scalechanging', arg);
					this.eventBus.dispatch('scalechange', arg);
				}
			}, {
				key: '_setScaleUpdatePages',
				value: function _setScaleUpdatePages(newScale, newValue) {
					var noScroll = arguments.length > 2 && arguments[2] !== undefined ?
						arguments[2] : false;
					var preset = arguments.length > 3 && arguments[3] !== undefined ?
						arguments[3] : false;
					this._currentScaleValue = newValue.toString();
					if (isSameScale(this._currentScale, newScale)) {
						if (preset) {
							this._setScaleDispatchEvent(newScale, newValue, true);
						}
						return;
					}
					for (var i = 0, ii = this._pages.length; i < ii; i++) {
						this._pages[i].update(newScale);
					}
					this._currentScale = newScale;
					if (!noScroll) {
						var page = this._currentPageNumber,
							dest = void 0;
						if (this._location && !_pdfjsLib.PDFJS
							.ignoreCurrentPositionOnZoom && !(this.isInPresentationMode ||
								this.isChangingPresentationMode)) {
							page = this._location.pageNumber;
							dest = [null, {
								name: 'XYZ'
							}, this._location.left, this._location.top, null];
						}
						this.scrollPageIntoView({
							pageNumber: page,
							destArray: dest,
							allowNegativeOffset: true
						});
					}
					this._setScaleDispatchEvent(newScale, newValue, preset);
					if (this.defaultRenderingQueue) {
						this.update();
					}
				}
			}, {
				key: '_setScale',
				value: function _setScale(value) {
					var noScroll = arguments.length > 1 && arguments[1] !== undefined ?
						arguments[1] : false;
					var scale = parseFloat(value);
					if (scale > 0) {
						this._setScaleUpdatePages(scale, value, noScroll, false);
					} else {
						var currentPage = this._pages[this._currentPageNumber - 1];
						if (!currentPage) {
							return;
						}
						var hPadding = this.isInPresentationMode || this.removePageBorders ?
							0 : _ui_utils.SCROLLBAR_PADDING;
						var vPadding = this.isInPresentationMode || this.removePageBorders ?
							0 : _ui_utils.VERTICAL_PADDING;
						var pageWidthScale = (this.container.clientWidth - hPadding) /
							currentPage.width * currentPage.scale;
						var pageHeightScale = (this.container.clientHeight - vPadding) /
							currentPage.height * currentPage.scale;
						switch (value) {
							case 'page-actual':
								scale = 1;
								break;
							case 'page-width':
								scale = pageWidthScale;
								break;
							case 'page-height':
								scale = pageHeightScale;
								break;
							case 'page-fit':
								scale = Math.min(pageWidthScale, pageHeightScale);
								break;
							case 'auto':
								var isLandscape = currentPage.width > currentPage.height;
								var horizontalScale = isLandscape ? Math.min(
									pageHeightScale, pageWidthScale) : pageWidthScale;
								scale = Math.min(_ui_utils.MAX_AUTO_SCALE, horizontalScale);
								break;
							default:
								console.error(this._name + '._setScale: "' + value +
									'" is an unknown zoom value.');
								return;
						}
						this._setScaleUpdatePages(scale, value, noScroll, true);
					}
				}
			}, {
				key: '_resetCurrentPageView',
				value: function _resetCurrentPageView() {
					if (this.isInPresentationMode) {
						this._setScale(this._currentScaleValue, true);
					}
					var pageView = this._pages[this._currentPageNumber - 1];
					this._scrollIntoView({
						pageDiv: pageView.div
					});
				}
			}, {
				key: 'scrollPageIntoView',
				value: function scrollPageIntoView(params) {
					if (arguments.length > 1 || typeof params === 'number') {
						console.error(
							'Call of scrollPageIntoView() with obsolete signature.');
						return;
					}
					if (!this.pdfDocument) {
						return;
					}
					var pageNumber = params.pageNumber || 0;
					var dest = params.destArray || null;
					var allowNegativeOffset = params.allowNegativeOffset || false;
					if (this.isInPresentationMode || !dest) {
						this._setCurrentPageNumber(pageNumber, true);
						return;
					}
					var pageView = this._pages[pageNumber - 1];
					if (!pageView) {
						console.error(this._name +
							'.scrollPageIntoView: Invalid "pageNumber" parameter.');
						return;
					}
					var x = 0,
						y = 0;
					var width = 0,
						height = 0,
						widthScale = void 0,
						heightScale = void 0;
					var changeOrientation = pageView.rotation % 180 === 0 ? false : true;
					var pageWidth = (changeOrientation ? pageView.height : pageView.width) /
						pageView.scale / _ui_utils.CSS_UNITS;
					var pageHeight = (changeOrientation ? pageView.width : pageView
						.height) / pageView.scale / _ui_utils.CSS_UNITS;
					var scale = 0;
					switch (dest[1].name) {
						case 'XYZ':
							x = dest[2];
							y = dest[3];
							scale = dest[4];
							x = x !== null ? x : 0;
							y = y !== null ? y : pageHeight;
							break;
						case 'Fit':
						case 'FitB':
							scale = 'page-fit';
							break;
						case 'FitH':
						case 'FitBH':
							y = dest[2];
							scale = 'page-width';
							if (y === null && this._location) {
								x = this._location.left;
								y = this._location.top;
							}
							break;
						case 'FitV':
						case 'FitBV':
							x = dest[2];
							width = pageWidth;
							height = pageHeight;
							scale = 'page-height';
							break;
						case 'FitR':
							x = dest[2];
							y = dest[3];
							width = dest[4] - x;
							height = dest[5] - y;
							var hPadding = this.removePageBorders ? 0 : _ui_utils
								.SCROLLBAR_PADDING;
							var vPadding = this.removePageBorders ? 0 : _ui_utils
								.VERTICAL_PADDING;
							widthScale = (this.container.clientWidth - hPadding) / width /
								_ui_utils.CSS_UNITS;
							heightScale = (this.container.clientHeight - vPadding) /
								height / _ui_utils.CSS_UNITS;
							scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));
							break;
						default:
							console.error(this._name + '.scrollPageIntoView: "' + dest[1]
								.name + '" ' + 'is not a valid destination type.');
							return;
					}
					if (scale && scale !== this._currentScale) {
						this.currentScaleValue = scale;
					} else if (this._currentScale === _ui_utils.UNKNOWN_SCALE) {
						this.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
					}
					if (scale === 'page-fit' && !dest[4]) {
						this._scrollIntoView({
							pageDiv: pageView.div,
							pageNumber: pageNumber
						});
						return;
					}
					var boundingRect = [pageView.viewport.convertToViewportPoint(x, y),
						pageView.viewport.convertToViewportPoint(x + width, y + height)
					];
					var left = Math.min(boundingRect[0][0], boundingRect[1][0]);
					var top = Math.min(boundingRect[0][1], boundingRect[1][1]);
					if (!allowNegativeOffset) {
						left = Math.max(left, 0);
						top = Math.max(top, 0);
					}
					this._scrollIntoView({
						pageDiv: pageView.div,
						pageSpot: {
							left: left,
							top: top
						},
						pageNumber: pageNumber
					});
				}
			}, {
				key: '_resizeBuffer',
				value: function _resizeBuffer(numVisiblePages) {
					var suggestedCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 *
						numVisiblePages + 1);
					this._buffer.resize(suggestedCacheSize);
				}
			}, {
				key: '_updateLocation',
				value: function _updateLocation(firstPage) {
					var currentScale = this._currentScale;
					var currentScaleValue = this._currentScaleValue;
					var normalizedScaleValue = parseFloat(currentScaleValue) ===
						currentScale ? Math.round(currentScale * 10000) / 100 :
						currentScaleValue;
					var pageNumber = firstPage.id;
					var pdfOpenParams = '#page=' + pageNumber;
					pdfOpenParams += '&zoom=' + normalizedScaleValue;
					var currentPageView = this._pages[pageNumber - 1];
					var container = this.container;
					var topLeft = currentPageView.getPagePoint(container.scrollLeft -
						firstPage.x, container.scrollTop - firstPage.y);
					var intLeft = Math.round(topLeft[0]);
					var intTop = Math.round(topLeft[1]);
					pdfOpenParams += ',' + intLeft + ',' + intTop;
					this._location = {
						pageNumber: pageNumber,
						scale: normalizedScaleValue,
						top: intTop,
						left: intLeft,
						rotation: this._pagesRotation,
						pdfOpenParams: pdfOpenParams
					};
				}
			}, {
				key: 'update',
				value: function update() {
					throw new Error('Not implemented: update');
				}
			}, {
				key: 'containsElement',
				value: function containsElement(element) {
					return this.container.contains(element);
				}
			}, {
				key: 'focus',
				value: function focus() {
					this.container.focus();
				}
			}, {
				key: '_getVisiblePages',
				value: function _getVisiblePages() {
					throw new Error('Not implemented: _getVisiblePages');
				}
			}, {
				key: 'cleanup',
				value: function cleanup() {
					for (var i = 0, ii = this._pages.length; i < ii; i++) {
						if (this._pages[i] && this._pages[i].renderingState !==
							_pdf_rendering_queue.RenderingStates.FINISHED) {
							this._pages[i].reset();
						}
					}
				}
			}, {
				key: '_cancelRendering',
				value: function _cancelRendering() {
					for (var i = 0, ii = this._pages.length; i < ii; i++) {
						if (this._pages[i]) {
							this._pages[i].cancelRendering();
						}
					}
				}
			}, {
				key: '_ensurePdfPageLoaded',
				value: function _ensurePdfPageLoaded(pageView) {
					var _this2 = this;
					if (pageView.pdfPage) {
						return Promise.resolve(pageView.pdfPage);
					}
					var pageNumber = pageView.id;
					if (this._pagesRequests[pageNumber]) {
						return this._pagesRequests[pageNumber];
					}
					var promise = this.pdfDocument.getPage(pageNumber).then(function(
						pdfPage) {
						if (!pageView.pdfPage) {
							pageView.setPdfPage(pdfPage);
						}
						_this2._pagesRequests[pageNumber] = null;
						return pdfPage;
					}).catch(function(reason) {
						console.error('Unable to get page for page view', reason);
						_this2._pagesRequests[pageNumber] = null;
					});
					this._pagesRequests[pageNumber] = promise;
					return promise;
				}
			}, {
				key: 'forceRendering',
				value: function forceRendering(currentlyVisiblePages) {
					var _this3 = this;
					var visiblePages = currentlyVisiblePages || this._getVisiblePages();
					var pageView = this.renderingQueue.getHighestPriority(visiblePages, this
						._pages, this.scroll.down);
					if (pageView) {
						this._ensurePdfPageLoaded(pageView).then(function() {
							_this3.renderingQueue.renderView(pageView);
						});
						return true;
					}
					return false;
				}
			}, {
				key: 'getPageTextContent',
				value: function getPageTextContent(pageIndex) {
					return this.pdfDocument.getPage(pageIndex + 1).then(function(page) {
						return page.getTextContent({
							normalizeWhitespace: true
						});
					});
				}
			}, {
				key: 'createTextLayerBuilder',
				value: function createTextLayerBuilder(textLayerDiv, pageIndex, viewport) {
					var enhanceTextSelection = arguments.length > 3 && arguments[3] !==
						undefined ? arguments[3] : false;
					return new _text_layer_builder.TextLayerBuilder({
						textLayerDiv: textLayerDiv,
						eventBus: this.eventBus,
						pageIndex: pageIndex,
						viewport: viewport,
						findController: this.isInPresentationMode ? null : this
							.findController,
						enhanceTextSelection: this.isInPresentationMode ? false :
							enhanceTextSelection
					});
				}
			}, {
				key: 'createAnnotationLayerBuilder',
				value: function createAnnotationLayerBuilder(pageDiv, pdfPage) {
					var renderInteractiveForms = arguments.length > 2 && arguments[2] !==
						undefined ? arguments[2] : false;
					var l10n = arguments.length > 3 && arguments[3] !== undefined ?
						arguments[3] : _ui_utils.NullL10n;
					return new _annotation_layer_builder.AnnotationLayerBuilder({
						pageDiv: pageDiv,
						pdfPage: pdfPage,
						renderInteractiveForms: renderInteractiveForms,
						linkService: this.linkService,
						downloadManager: this.downloadManager,
						l10n: l10n
					});
				}
			}, {
				key: 'setFindController',
				value: function setFindController(findController) {
					this.findController = findController;
				}
			}, {
				key: 'getPagesOverview',
				value: function getPagesOverview() {
					var pagesOverview = this._pages.map(function(pageView) {
						var viewport = pageView.pdfPage.getViewport(1);
						return {
							width: viewport.width,
							height: viewport.height,
							rotation: viewport.rotation
						};
					});
					if (!this.enablePrintAutoRotate) {
						return pagesOverview;
					}
					var isFirstPagePortrait = isPortraitOrientation(pagesOverview[0]);
					return pagesOverview.map(function(size) {
						if (isFirstPagePortrait === isPortraitOrientation(size)) {
							return size;
						}
						return {
							width: size.height,
							height: size.width,
							rotation: (size.rotation + 90) % 360
						};
					});
				}
			}, {
				key: 'pagesCount',
				get: function get() {
					return this._pages.length;
				}
			}, {
				key: 'pageViewsReady',
				get: function get() {
					return this._pageViewsReady;
				}
			}, {
				key: 'currentPageNumber',
				get: function get() {
					return this._currentPageNumber;
				},
				set: function set(val) {
					if (!Number.isInteger(val)) {
						throw new Error('Invalid page number.');
					}
					if (!this.pdfDocument) {
						return;
					}
					this._setCurrentPageNumber(val, true);
				}
			}, {
				key: 'currentPageLabel',
				get: function get() {
					return this._pageLabels && this._pageLabels[this._currentPageNumber -
					1];
				},
				set: function set(val) {
					var pageNumber = val | 0;
					if (this._pageLabels) {
						var i = this._pageLabels.indexOf(val);
						if (i >= 0) {
							pageNumber = i + 1;
						}
					}
					this.currentPageNumber = pageNumber;
				}
			}, {
				key: 'currentScale',
				get: function get() {
					return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this
						._currentScale : _ui_utils.DEFAULT_SCALE;
				},
				set: function set(val) {
					if (isNaN(val)) {
						throw new Error('Invalid numeric scale');
					}
					if (!this.pdfDocument) {
						return;
					}
					this._setScale(val, false);
				}
			}, {
				key: 'currentScaleValue',
				get: function get() {
					return this._currentScaleValue;
				},
				set: function set(val) {
					if (!this.pdfDocument) {
						return;
					}
					this._setScale(val, false);
				}
			}, {
				key: 'pagesRotation',
				get: function get() {
					return this._pagesRotation;
				},
				set: function set(rotation) {
					if (!(0,
							_ui_utils.isValidRotation)(rotation)) {
						throw new Error('Invalid pages rotation angle.');
					}
					if (!this.pdfDocument) {
						return;
					}
					if (this._pagesRotation === rotation) {
						return;
					}
					this._pagesRotation = rotation;
					var pageNumber = this._currentPageNumber;
					for (var i = 0, ii = this._pages.length; i < ii; i++) {
						var pageView = this._pages[i];
						pageView.update(pageView.scale, rotation);
					}
					if (this._currentScaleValue) {
						this._setScale(this._currentScaleValue, true);
					}
					this.eventBus.dispatch('rotationchanging', {
						source: this,
						pagesRotation: rotation,
						pageNumber: pageNumber
					});
					if (this.defaultRenderingQueue) {
						this.update();
					}
				}
			}, {
				key: '_setDocumentViewerElement',
				get: function get() {
					throw new Error('Not implemented: _setDocumentViewerElement');
				}
			}, {
				key: 'isInPresentationMode',
				get: function get() {
					return this.presentationModeState === _ui_utils.PresentationModeState
						.FULLSCREEN;
				}
			}, {
				key: 'isChangingPresentationMode',
				get: function get() {
					return this.presentationModeState === _ui_utils.PresentationModeState
						.CHANGING;
				}
			}, {
				key: 'isHorizontalScrollbarEnabled',
				get: function get() {
					return this.isInPresentationMode ? false : this.container.scrollWidth >
						this.container.clientWidth;
				}
			}, {
				key: 'hasEqualPageSizes',
				get: function get() {
					var firstPageView = this._pages[0];
					for (var i = 1, ii = this._pages.length; i < ii; ++i) {
						var pageView = this._pages[i];
						if (pageView.width !== firstPageView.width || pageView.height !==
							firstPageView.height) {
							return false;
						}
					}
					return true;
				}
			}]);
			return BaseViewer;
		}();
		exports.BaseViewer = BaseViewer;
	}), /* 23 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.DefaultAnnotationLayerFactory = exports.AnnotationLayerBuilder = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdfjsLib = __webpack_require__(1);
		var _ui_utils = __webpack_require__(0);
		var _pdf_link_service = __webpack_require__(5);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var AnnotationLayerBuilder = function() {
			function AnnotationLayerBuilder(_ref) {
				var pageDiv = _ref.pageDiv,
					pdfPage = _ref.pdfPage,
					linkService = _ref.linkService,
					downloadManager = _ref.downloadManager,
					_ref$renderInteractiv = _ref.renderInteractiveForms,
					renderInteractiveForms = _ref$renderInteractiv === undefined ? false :
					_ref$renderInteractiv,
					_ref$l10n = _ref.l10n,
					l10n = _ref$l10n === undefined ? _ui_utils.NullL10n : _ref$l10n;
				_classCallCheck(this, AnnotationLayerBuilder);
				this.pageDiv = pageDiv;
				this.pdfPage = pdfPage;
				this.linkService = linkService;
				this.downloadManager = downloadManager;
				this.renderInteractiveForms = renderInteractiveForms;
				this.l10n = l10n;
				this.div = null;
				this._cancelled = false;
			}
			_createClass(AnnotationLayerBuilder, [{
				key: 'render',
				value: function render(viewport) {
					var _this = this;
					var intent = arguments.length > 1 && arguments[1] !== undefined ?
						arguments[1] : 'display';
					this.pdfPage.getAnnotations({
						intent: intent
					}).then(function(annotations) {
						if (_this._cancelled) {
							return;
						}
						var parameters = {
							viewport: viewport.clone({
								dontFlip: true
							}),
							div: _this.div,
							annotations: annotations,
							page: _this.pdfPage,
							renderInteractiveForms: _this
								.renderInteractiveForms,
							linkService: _this.linkService,
							downloadManager: _this.downloadManager
						};
						if (_this.div) {
							_pdfjsLib.AnnotationLayer.update(parameters);
						} else {
							if (annotations.length === 0) {
								return;
							}
							_this.div = document.createElement('div');
							_this.div.className = 'annotationLayer';
							_this.pageDiv.appendChild(_this.div);
							parameters.div = _this.div;
							_pdfjsLib.AnnotationLayer.render(parameters);
							_this.l10n.translate(_this.div);
						}
					});
				}
			}, {
				key: 'cancel',
				value: function cancel() {
					this._cancelled = true;
				}
			}, {
				key: 'hide',
				value: function hide() {
					if (!this.div) {
						return;
					}
					this.div.setAttribute('hidden', 'true');
				}
			}]);
			return AnnotationLayerBuilder;
		}();
		var DefaultAnnotationLayerFactory = function() {
			function DefaultAnnotationLayerFactory() {
				_classCallCheck(this, DefaultAnnotationLayerFactory);
			}
			_createClass(DefaultAnnotationLayerFactory, [{
				key: 'createAnnotationLayerBuilder',
				value: function createAnnotationLayerBuilder(pageDiv, pdfPage) {
					var renderInteractiveForms = arguments.length > 2 && arguments[2] !==
						undefined ? arguments[2] : false;
					var l10n = arguments.length > 3 && arguments[3] !== undefined ?
						arguments[3] : _ui_utils.NullL10n;
					return new AnnotationLayerBuilder({
						pageDiv: pageDiv,
						pdfPage: pdfPage,
						renderInteractiveForms: renderInteractiveForms,
						linkService: new _pdf_link_service.SimpleLinkService(),
						l10n: l10n
					});
				}
			}]);
			return DefaultAnnotationLayerFactory;
		}();
		exports.AnnotationLayerBuilder = AnnotationLayerBuilder;
		exports.DefaultAnnotationLayerFactory = DefaultAnnotationLayerFactory;
	}), /* 24 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFPageView = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);
		var _pdfjsLib = __webpack_require__(1);
		var _dom_events = __webpack_require__(2);
		var _pdf_rendering_queue = __webpack_require__(3);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var PDFPageView = function() {
			function PDFPageView(options) {
				_classCallCheck(this, PDFPageView);
				var container = options.container;
				var defaultViewport = options.defaultViewport;
				this.id = options.id;
				this.renderingId = 'page' + this.id;
				this.pdfPage = null;
				this.pageLabel = null;
				this.rotation = 0;
				this.scale = options.scale || _ui_utils.DEFAULT_SCALE;
				this.viewport = defaultViewport;
				this.pdfPageRotate = defaultViewport.rotation;
				this.hasRestrictedScaling = false;
				this.enhanceTextSelection = options.enhanceTextSelection || false;
				this.renderInteractiveForms = options.renderInteractiveForms || false;
				this.eventBus = options.eventBus || (0,
					_dom_events.getGlobalEventBus)();
				this.renderingQueue = options.renderingQueue;
				this.textLayerFactory = options.textLayerFactory;
				this.annotationLayerFactory = options.annotationLayerFactory;
				this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
				this.l10n = options.l10n || _ui_utils.NullL10n;
				this.paintTask = null;
				this.paintedViewportMap = new WeakMap();
				this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
				this.resume = null;
				this.error = null;
				this.onBeforeDraw = null;
				this.onAfterDraw = null;
				this.annotationLayer = null;
				this.textLayer = null;
				this.zoomLayer = null;
				var div = document.createElement('div');
				div.className = 'page';
				div.style.width = Math.floor(this.viewport.width) + 'px';
				div.style.height = Math.floor(this.viewport.height) + 'px';
				div.setAttribute('data-page-number', this.id);
				this.div = div;
				container.appendChild(div);
			}
			_createClass(PDFPageView, [{
				key: 'setPdfPage',
				value: function setPdfPage(pdfPage) {
					this.pdfPage = pdfPage;
					this.pdfPageRotate = pdfPage.rotate;
					var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
					this.viewport = pdfPage.getViewport(this.scale * _ui_utils.CSS_UNITS,
						totalRotation);
					this.stats = pdfPage.stats;
					this.reset();
				}
			}, {
				key: 'destroy',
				value: function destroy() {
					this.reset();
					if (this.pdfPage) {
						this.pdfPage.cleanup();
					}
				}
			}, {
				key: '_resetZoomLayer',
				value: function _resetZoomLayer() {
					var removeFromDOM = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : false;
					if (!this.zoomLayer) {
						return;
					}
					var zoomLayerCanvas = this.zoomLayer.firstChild;
					this.paintedViewportMap.delete(zoomLayerCanvas);
					zoomLayerCanvas.width = 0;
					zoomLayerCanvas.height = 0;
					if (removeFromDOM) {
						this.zoomLayer.remove();
					}
					this.zoomLayer = null;
				}
			}, {
				key: 'reset',
				value: function reset() {
					var keepZoomLayer = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : false;
					var keepAnnotations = arguments.length > 1 && arguments[1] !==
						undefined ? arguments[1] : false;
					this.cancelRendering(keepAnnotations);
					var div = this.div;
					div.style.width = Math.floor(this.viewport.width) + 'px';
					div.style.height = Math.floor(this.viewport.height) + 'px';
					var childNodes = div.childNodes;
					var currentZoomLayerNode = keepZoomLayer && this.zoomLayer || null;
					var currentAnnotationNode = keepAnnotations && this.annotationLayer &&
						this.annotationLayer.div || null;
					for (var i = childNodes.length - 1; i >= 0; i--) {
						var node = childNodes[i];
						if (currentZoomLayerNode === node || currentAnnotationNode ===
							node) {
							continue;
						}
						div.removeChild(node);
					}
					div.removeAttribute('data-loaded');
					if (currentAnnotationNode) {
						this.annotationLayer.hide();
					} else if (this.annotationLayer) {
						this.annotationLayer.cancel();
						this.annotationLayer = null;
					}
					if (!currentZoomLayerNode) {
						if (this.canvas) {
							this.paintedViewportMap.delete(this.canvas);
							this.canvas.width = 0;
							this.canvas.height = 0;
							delete this.canvas;
						}
						this._resetZoomLayer();
					}
					if (this.svg) {
						this.paintedViewportMap.delete(this.svg);
						delete this.svg;
					}
					this.loadingIconDiv = document.createElement('div');
					this.loadingIconDiv.className = 'loadingIcon';
					div.appendChild(this.loadingIconDiv);
				}
			}, {
				key: 'update',
				value: function update(scale, rotation) {
					this.scale = scale || this.scale;
					if (typeof rotation !== 'undefined') {
						this.rotation = rotation;
					}
					var totalRotation = (this.rotation + this.pdfPageRotate) % 360;
					this.viewport = this.viewport.clone({
						scale: this.scale * _ui_utils.CSS_UNITS,
						rotation: totalRotation
					});
					if (this.svg) {
						this.cssTransform(this.svg, true);
						this.eventBus.dispatch('pagerendered', {
							source: this,
							pageNumber: this.id,
							cssTransform: true
						});
						return;
					}
					var isScalingRestricted = false;
					if (this.canvas && _pdfjsLib.PDFJS.maxCanvasPixels > 0) {
						var outputScale = this.outputScale;
						if ((Math.floor(this.viewport.width) * outputScale.sx | 0) * (Math
								.floor(this.viewport.height) * outputScale.sy | 0) >
							_pdfjsLib.PDFJS.maxCanvasPixels) {
							isScalingRestricted = true;
						}
					}
					if (this.canvas) {
						if (_pdfjsLib.PDFJS.useOnlyCssZoom || this.hasRestrictedScaling &&
							isScalingRestricted) {
							this.cssTransform(this.canvas, true);
							this.eventBus.dispatch('pagerendered', {
								source: this,
								pageNumber: this.id,
								cssTransform: true
							});
							return;
						}
						if (!this.zoomLayer && !this.canvas.hasAttribute('hidden')) {
							this.zoomLayer = this.canvas.parentNode;
							this.zoomLayer.style.position = 'absolute';
						}
					}
					if (this.zoomLayer) {
						this.cssTransform(this.zoomLayer.firstChild);
					}
					this.reset(true, true);
				}
			}, {
				key: 'cancelRendering',
				value: function cancelRendering() {
					var keepAnnotations = arguments.length > 0 && arguments[0] !==
						undefined ? arguments[0] : false;
					if (this.paintTask) {
						this.paintTask.cancel();
						this.paintTask = null;
					}
					this.renderingState = _pdf_rendering_queue.RenderingStates.INITIAL;
					this.resume = null;
					if (this.textLayer) {
						this.textLayer.cancel();
						this.textLayer = null;
					}
					if (!keepAnnotations && this.annotationLayer) {
						this.annotationLayer.cancel();
						this.annotationLayer = null;
					}
				}
			}, {
				key: 'cssTransform',
				value: function cssTransform(target) {
					var redrawAnnotations = arguments.length > 1 && arguments[1] !==
						undefined ? arguments[1] : false;
					var width = this.viewport.width;
					var height = this.viewport.height;
					var div = this.div;
					target.style.width = target.parentNode.style.width = div.style.width =
						Math.floor(width) + 'px';
					target.style.height = target.parentNode.style.height = div.style
						.height = Math.floor(height) + 'px';
					var relativeRotation = this.viewport.rotation - this.paintedViewportMap
						.get(target).rotation;
					var absRotation = Math.abs(relativeRotation);
					var scaleX = 1,
						scaleY = 1;
					if (absRotation === 90 || absRotation === 270) {
						scaleX = height / width;
						scaleY = width / height;
					}
					var cssTransform = 'rotate(' + relativeRotation + 'deg) ' + 'scale(' +
						scaleX + ',' + scaleY + ')';
					_pdfjsLib.CustomStyle.setProp('transform', target, cssTransform);
					if (this.textLayer) {
						var textLayerViewport = this.textLayer.viewport;
						var textRelativeRotation = this.viewport.rotation -
							textLayerViewport.rotation;
						var textAbsRotation = Math.abs(textRelativeRotation);
						var scale = width / textLayerViewport.width;
						if (textAbsRotation === 90 || textAbsRotation === 270) {
							scale = width / textLayerViewport.height;
						}
						var textLayerDiv = this.textLayer.textLayerDiv;
						var transX = void 0,
							transY = void 0;
						switch (textAbsRotation) {
							case 0:
								transX = transY = 0;
								break;
							case 90:
								transX = 0;
								transY = '-' + textLayerDiv.style.height;
								break;
							case 180:
								transX = '-' + textLayerDiv.style.width;
								transY = '-' + textLayerDiv.style.height;
								break;
							case 270:
								transX = '-' + textLayerDiv.style.width;
								transY = 0;
								break;
							default:
								console.error('Bad rotation value.');
								break;
						}
						_pdfjsLib.CustomStyle.setProp('transform', textLayerDiv, 'rotate(' +
							textAbsRotation + 'deg) ' + 'scale(' + scale + ', ' +
							scale + ') ' + 'translate(' + transX + ', ' + transY + ')');
						_pdfjsLib.CustomStyle.setProp('transformOrigin', textLayerDiv,
							'0% 0%');
					}
					if (redrawAnnotations && this.annotationLayer) {
						this.annotationLayer.render(this.viewport, 'display');
					}
				}
			}, {
				key: 'getPagePoint',
				value: function getPagePoint(x, y) {
					return this.viewport.convertToPdfPoint(x, y);
				}
			}, {
				key: 'draw',
				value: function draw() {
					var _this = this;
					if (this.renderingState !== _pdf_rendering_queue.RenderingStates
						.INITIAL) {
						console.error('Must be in new state before drawing');
						this.reset();
					}
					if (!this.pdfPage) {
						this.renderingState = _pdf_rendering_queue.RenderingStates.FINISHED;
						return Promise.reject(new Error('Page is not loaded'));
					}
					this.renderingState = _pdf_rendering_queue.RenderingStates.RUNNING;
					var pdfPage = this.pdfPage;
					var div = this.div;
					var canvasWrapper = document.createElement('div');
					canvasWrapper.style.width = div.style.width;
					canvasWrapper.style.height = div.style.height;
					canvasWrapper.classList.add('canvasWrapper');
					if (this.annotationLayer && this.annotationLayer.div) {
						div.insertBefore(canvasWrapper, this.annotationLayer.div);
					} else {
						div.appendChild(canvasWrapper);
					}
					var textLayer = null;
					if (this.textLayerFactory) {
						var textLayerDiv = document.createElement('div');
						textLayerDiv.className = 'textLayer';
						textLayerDiv.style.width = canvasWrapper.style.width;
						textLayerDiv.style.height = canvasWrapper.style.height;
						if (this.annotationLayer && this.annotationLayer.div) {
							div.insertBefore(textLayerDiv, this.annotationLayer.div);
						} else {
							div.appendChild(textLayerDiv);
						}
						textLayer = this.textLayerFactory.createTextLayerBuilder(
							textLayerDiv, this.id - 1, this.viewport, this
							.enhanceTextSelection);
					}
					this.textLayer = textLayer;
					var renderContinueCallback = null;
					if (this.renderingQueue) {
						renderContinueCallback = function renderContinueCallback(cont) {
							if (!_this.renderingQueue.isHighestPriority(_this)) {
								_this.renderingState = _pdf_rendering_queue
									.RenderingStates.PAUSED;
								_this.resume = function() {
									_this.renderingState = _pdf_rendering_queue
										.RenderingStates.RUNNING;
									cont();
								};
								return;
							}
							cont();
						};
					}
					var finishPaintTask = function finishPaintTask(error) {
						if (paintTask === _this.paintTask) {
							_this.paintTask = null;
						}
						if (error === 'cancelled' || error instanceof _pdfjsLib
							.RenderingCancelledException) {
							_this.error = null;
							return Promise.resolve(undefined);
						}
						_this.renderingState = _pdf_rendering_queue.RenderingStates
							.FINISHED;
						if (_this.loadingIconDiv) {
							div.removeChild(_this.loadingIconDiv);
							delete _this.loadingIconDiv;
						}
						_this._resetZoomLayer(true);
						_this.error = error;
						_this.stats = pdfPage.stats;
						if (_this.onAfterDraw) {
							_this.onAfterDraw();
						}
						_this.eventBus.dispatch('pagerendered', {
							source: _this,
							pageNumber: _this.id,
							cssTransform: false
						});
						if (error) {
							return Promise.reject(error);
						}
						return Promise.resolve(undefined);
					};
					var paintTask = this.renderer === _ui_utils.RendererType.SVG ? this
						.paintOnSvg(canvasWrapper) : this.paintOnCanvas(canvasWrapper);
					paintTask.onRenderContinue = renderContinueCallback;
					this.paintTask = paintTask;
					var resultPromise = paintTask.promise.then(function() {
						return finishPaintTask(null).then(function() {
							if (textLayer) {
								var readableStream = pdfPage
									.streamTextContent({
										normalizeWhitespace: true
									});
								textLayer.setTextContentStream(
									readableStream);
								textLayer.render();
							}
						});
					}, function(reason) {
						return finishPaintTask(reason);
					});
					if (this.annotationLayerFactory) {
						if (!this.annotationLayer) {
							this.annotationLayer = this.annotationLayerFactory
								.createAnnotationLayerBuilder(div, pdfPage, this
									.renderInteractiveForms, this.l10n);
						}
						this.annotationLayer.render(this.viewport, 'display');
					}
					div.setAttribute('data-loaded', true);
					if (this.onBeforeDraw) {
						this.onBeforeDraw();
					}
					return resultPromise;
				}
			}, {
				key: 'paintOnCanvas',
				value: function paintOnCanvas(canvasWrapper) {
					var renderCapability = (0,
						_pdfjsLib.createPromiseCapability)();
					var result = {
						promise: renderCapability.promise,
						onRenderContinue: function onRenderContinue(cont) {
							cont();
						},
						cancel: function cancel() {
							renderTask.cancel();
						}
					};
					var viewport = this.viewport;
					var canvas = document.createElement('canvas');
					canvas.id = this.renderingId;
					canvas.setAttribute('hidden', 'hidden');
					var isCanvasHidden = true;
					var showCanvas = function showCanvas() {
						if (isCanvasHidden) {
							canvas.removeAttribute('hidden');
							isCanvasHidden = false;
						}
					};
					canvasWrapper.appendChild(canvas);
					this.canvas = canvas;
					canvas.mozOpaque = true;
					var ctx = canvas.getContext('2d', {
						alpha: false
					});
					var outputScale = (0,
						_ui_utils.getOutputScale)(ctx);
					this.outputScale = outputScale;
					if (_pdfjsLib.PDFJS.useOnlyCssZoom) {
						var actualSizeViewport = viewport.clone({
							scale: _ui_utils.CSS_UNITS
						});
						outputScale.sx *= actualSizeViewport.width / viewport.width;
						outputScale.sy *= actualSizeViewport.height / viewport.height;
						outputScale.scaled = true;
					}
					if (_pdfjsLib.PDFJS.maxCanvasPixels > 0) {
						var pixelsInViewport = viewport.width * viewport.height;
						var maxScale = Math.sqrt(_pdfjsLib.PDFJS.maxCanvasPixels /
							pixelsInViewport);
						if (outputScale.sx > maxScale || outputScale.sy > maxScale) {
							outputScale.sx = maxScale;
							outputScale.sy = maxScale;
							outputScale.scaled = true;
							this.hasRestrictedScaling = true;
						} else {
							this.hasRestrictedScaling = false;
						}
					}
					var sfx = (0,
						_ui_utils.approximateFraction)(outputScale.sx);
					var sfy = (0,
						_ui_utils.approximateFraction)(outputScale.sy);
					canvas.width = (0,
						_ui_utils.roundToDivide)(viewport.width * outputScale.sx, sfx[
						0]);
					canvas.height = (0,
						_ui_utils.roundToDivide)(viewport.height * outputScale.sy, sfy[
						0]);
					canvas.style.width = (0,
						_ui_utils.roundToDivide)(viewport.width, sfx[1]) + 'px';
					canvas.style.height = (0,
						_ui_utils.roundToDivide)(viewport.height, sfy[1]) + 'px';
					this.paintedViewportMap.set(canvas, viewport);
					var transform = !outputScale.scaled ? null : [outputScale.sx, 0, 0,
						outputScale.sy, 0, 0
					];
					var renderContext = {
						canvasContext: ctx,
						transform: transform,
						viewport: this.viewport,
						renderInteractiveForms: this.renderInteractiveForms
					};
					var renderTask = this.pdfPage.render(renderContext);
					renderTask.onContinue = function(cont) {
						showCanvas();
						if (result.onRenderContinue) {
							result.onRenderContinue(cont);
						} else {
							cont();
						}
					};
					renderTask.promise.then(function() {
						showCanvas();
						renderCapability.resolve(undefined);
					}, function(error) {
						showCanvas();
						renderCapability.reject(error);
					});
					return result;
				}
			}, {
				key: 'paintOnSvg',
				value: function paintOnSvg(wrapper) {
					var _this2 = this;
					var cancelled = false;
					var ensureNotCancelled = function ensureNotCancelled() {
						if (cancelled) {
							if (_pdfjsLib.PDFJS.pdfjsNext) {
								throw new _pdfjsLib.RenderingCancelledException(
									'Rendering cancelled, page ' + _this2.id, 'svg');
							} else {
								throw 'cancelled';
							}
						}
					};
					var pdfPage = this.pdfPage;
					var actualSizeViewport = this.viewport.clone({
						scale: _ui_utils.CSS_UNITS
					});
					var promise = pdfPage.getOperatorList().then(function(opList) {
						ensureNotCancelled();
						var svgGfx = new _pdfjsLib.SVGGraphics(pdfPage.commonObjs,
							pdfPage.objs);
						return svgGfx.getSVG(opList, actualSizeViewport).then(
							function(svg) {
								ensureNotCancelled();
								_this2.svg = svg;
								_this2.paintedViewportMap.set(svg,
									actualSizeViewport);
								svg.style.width = wrapper.style.width;
								svg.style.height = wrapper.style.height;
								_this2.renderingState = _pdf_rendering_queue
									.RenderingStates.FINISHED;
								wrapper.appendChild(svg);
							});
					});
					return {
						promise: promise,
						onRenderContinue: function onRenderContinue(cont) {
							cont();
						},
						cancel: function cancel() {
							cancelled = true;
						}
					};
				}
			}, {
				key: 'setPageLabel',
				value: function setPageLabel(label) {
					this.pageLabel = typeof label === 'string' ? label : null;
					if (this.pageLabel !== null) {
						this.div.setAttribute('data-page-label', this.pageLabel);
					} else {
						this.div.removeAttribute('data-page-label');
					}
				}
			}, {
				key: 'width',
				get: function get() {
					return this.viewport.width;
				}
			}, {
				key: 'height',
				get: function get() {
					return this.viewport.height;
				}
			}]);
			return PDFPageView;
		}();
		exports.PDFPageView = PDFPageView;
	}), /* 25 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.DefaultTextLayerFactory = exports.TextLayerBuilder = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _dom_events = __webpack_require__(2);
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var EXPAND_DIVS_TIMEOUT = 300;
		var TextLayerBuilder = function() {
			function TextLayerBuilder(_ref) {
				var textLayerDiv = _ref.textLayerDiv,
					eventBus = _ref.eventBus,
					pageIndex = _ref.pageIndex,
					viewport = _ref.viewport,
					_ref$findController = _ref.findController,
					findController = _ref$findController === undefined ? null : _ref$findController,
					_ref$enhanceTextSelec = _ref.enhanceTextSelection,
					enhanceTextSelection = _ref$enhanceTextSelec === undefined ? false :
					_ref$enhanceTextSelec;
				_classCallCheck(this, TextLayerBuilder);
				this.textLayerDiv = textLayerDiv;
				this.eventBus = eventBus || (0,
					_dom_events.getGlobalEventBus)();
				this.textContent = null;
				this.textContentItemsStr = [];
				this.textContentStream = null;
				this.renderingDone = false;
				this.pageIdx = pageIndex;
				this.pageNumber = this.pageIdx + 1;
				this.matches = [];
				this.viewport = viewport;
				this.textDivs = [];
				this.findController = findController;
				this.textLayerRenderTask = null;
				this.enhanceTextSelection = enhanceTextSelection;
				this._bindMouse();
			}
			_createClass(TextLayerBuilder, [{
				key: '_finishRendering',
				value: function _finishRendering() {
					this.renderingDone = true;
					if (!this.enhanceTextSelection) {
						var endOfContent = document.createElement('div');
						endOfContent.className = 'endOfContent';
						this.textLayerDiv.appendChild(endOfContent);
					}
					this.eventBus.dispatch('textlayerrendered', {
						source: this,
						pageNumber: this.pageNumber,
						numTextDivs: this.textDivs.length
					});
				}
			}, {
				key: 'render',
				value: function render() {
					var _this = this;
					var timeout = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : 0;
					if (!(this.textContent || this.textContentStream) || this
						.renderingDone) {
						return;
					}
					this.cancel();
					this.textDivs = [];
					var textLayerFrag = document.createDocumentFragment();
					this.textLayerRenderTask = (0,
						_pdfjsLib.renderTextLayer)({
						textContent: this.textContent,
						textContentStream: this.textContentStream,
						container: textLayerFrag,
						viewport: this.viewport,
						textDivs: this.textDivs,
						textContentItemsStr: this.textContentItemsStr,
						timeout: timeout,
						enhanceTextSelection: this.enhanceTextSelection
					});
					this.textLayerRenderTask.promise.then(function() {
						_this.textLayerDiv.appendChild(textLayerFrag);
						_this._finishRendering();
						_this.updateMatches();
					}, function(reason) {});
				}
			}, {
				key: 'cancel',
				value: function cancel() {
					if (this.textLayerRenderTask) {
						this.textLayerRenderTask.cancel();
						this.textLayerRenderTask = null;
					}
				}
			}, {
				key: 'setTextContentStream',
				value: function setTextContentStream(readableStream) {
					this.cancel();
					this.textContentStream = readableStream;
				}
			}, {
				key: 'setTextContent',
				value: function setTextContent(textContent) {
					this.cancel();
					this.textContent = textContent;
				}
			}, {
				key: 'convertMatches',
				value: function convertMatches(matches, matchesLength) {
					var i = 0;
					var iIndex = 0;
					var textContentItemsStr = this.textContentItemsStr;
					var end = textContentItemsStr.length - 1;
					var queryLen = this.findController === null ? 0 : this.findController
						.state.query.length;
					var ret = [];
					if (!matches) {
						return ret;
					}
					for (var m = 0, len = matches.length; m < len; m++) {
						var matchIdx = matches[m];
						while (i !== end && matchIdx >= iIndex + textContentItemsStr[i]
							.length) {
							iIndex += textContentItemsStr[i].length;
							i++;
						}
						if (i === textContentItemsStr.length) {
							console.error('Could not find a matching mapping');
						}
						var match = {
							begin: {
								divIdx: i,
								offset: matchIdx - iIndex
							}
						};
						if (matchesLength) {
							matchIdx += matchesLength[m];
						} else {
							matchIdx += queryLen;
						}
						while (i !== end && matchIdx > iIndex + textContentItemsStr[i]
							.length) {
							iIndex += textContentItemsStr[i].length;
							i++;
						}
						match.end = {
							divIdx: i,
							offset: matchIdx - iIndex
						};
						ret.push(match);
					}
					return ret;
				}
			}, {
				key: 'renderMatches',
				value: function renderMatches(matches) {
					if (matches.length === 0) {
						return;
					}
					var textContentItemsStr = this.textContentItemsStr;
					var textDivs = this.textDivs;
					var prevEnd = null;
					var pageIdx = this.pageIdx;
					var isSelectedPage = this.findController === null ? false : pageIdx ===
						this.findController.selected.pageIdx;
					var selectedMatchIdx = this.findController === null ? -1 : this
						.findController.selected.matchIdx;
					var highlightAll = this.findController === null ? false : this
						.findController.state.highlightAll;
					var infinity = {
						divIdx: -1,
						offset: undefined
					};

					function beginText(begin, className) {
						var divIdx = begin.divIdx;
						textDivs[divIdx].textContent = '';
						appendTextToDiv(divIdx, 0, begin.offset, className);
					}

					function appendTextToDiv(divIdx, fromOffset, toOffset, className) {
						var div = textDivs[divIdx];
						var content = textContentItemsStr[divIdx].substring(fromOffset,
							toOffset);
						var node = document.createTextNode(content);
						if (className) {
							var span = document.createElement('span');
							span.className = className;
							span.appendChild(node);
							div.appendChild(span);
							return;
						}
						div.appendChild(node);
					}
					var i0 = selectedMatchIdx,
						i1 = i0 + 1;
					if (highlightAll) {
						i0 = 0;
						i1 = matches.length;
					} else if (!isSelectedPage) {
						return;
					}
					for (var i = i0; i < i1; i++) {
						var match = matches[i];
						var begin = match.begin;
						var end = match.end;
						var isSelected = isSelectedPage && i === selectedMatchIdx;
						var highlightSuffix = isSelected ? ' selected' : '';
						if (this.findController) {
							this.findController.updateMatchPosition(pageIdx, i, textDivs,
								begin.divIdx);
						}
						if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
							if (prevEnd !== null) {
								appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity
									.offset);
							}
							beginText(begin);
						} else {
							appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset);
						}
						if (begin.divIdx === end.divIdx) {
							appendTextToDiv(begin.divIdx, begin.offset, end.offset,
								'highlight' + highlightSuffix);
						} else {
							appendTextToDiv(begin.divIdx, begin.offset, infinity.offset,
								'highlight begin' + highlightSuffix);
							for (var n0 = begin.divIdx + 1, n1 = end.divIdx; n0 <
								n1; n0++) {
								textDivs[n0].className = 'highlight middle' +
									highlightSuffix;
							}
							beginText(end, 'highlight end' + highlightSuffix);
						}
						prevEnd = end;
					}
					if (prevEnd) {
						appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);
					}
				}
			}, {
				key: 'updateMatches',
				value: function updateMatches() {
					if (!this.renderingDone) {
						return;
					}
					var matches = this.matches;
					var textDivs = this.textDivs;
					var textContentItemsStr = this.textContentItemsStr;
					var clearedUntilDivIdx = -1;
					for (var i = 0, len = matches.length; i < len; i++) {
						var match = matches[i];
						var begin = Math.max(clearedUntilDivIdx, match.begin.divIdx);
						for (var n = begin, end = match.end.divIdx; n <= end; n++) {
							var div = textDivs[n];
							div.textContent = textContentItemsStr[n];
							div.className = '';
						}
						clearedUntilDivIdx = match.end.divIdx + 1;
					}
					if (this.findController === null || !this.findController.active) {
						return;
					}
					var pageMatches = void 0,
						pageMatchesLength = void 0;
					if (this.findController !== null) {
						pageMatches = this.findController.pageMatches[this.pageIdx] || null;
						pageMatchesLength = this.findController.pageMatchesLength ? this
							.findController.pageMatchesLength[this.pageIdx] || null : null;
					}
					this.matches = this.convertMatches(pageMatches, pageMatchesLength);
					this.renderMatches(this.matches);
				}
			}, {
				key: '_bindMouse',
				value: function _bindMouse() {
					var _this2 = this;
					var div = this.textLayerDiv;
					var expandDivsTimer = null;
					div.addEventListener('mousedown', function(evt) {
						if (_this2.enhanceTextSelection && _this2
							.textLayerRenderTask) {
							_this2.textLayerRenderTask.expandTextDivs(true);
							if (expandDivsTimer) {
								clearTimeout(expandDivsTimer);
								expandDivsTimer = null;
							}
							return;
						}
						var end = div.querySelector('.endOfContent');
						if (!end) {
							return;
						}
						var adjustTop = evt.target !== div;
						adjustTop = adjustTop && window.getComputedStyle(end)
							.getPropertyValue('-moz-user-select') !== 'none';
						if (adjustTop) {
							var divBounds = div.getBoundingClientRect();
							var r = Math.max(0, (evt.pageY - divBounds.top) /
								divBounds.height);
							end.style.top = (r * 100).toFixed(2) + '%';
						}
						end.classList.add('active');
					});
					div.addEventListener('mouseup', function() {
						if (_this2.enhanceTextSelection && _this2
							.textLayerRenderTask) {
							expandDivsTimer = setTimeout(function() {
								if (_this2.textLayerRenderTask) {
									_this2.textLayerRenderTask
										.expandTextDivs(false);
								}
								expandDivsTimer = null;
							}, EXPAND_DIVS_TIMEOUT);
							return;
						}
						var end = div.querySelector('.endOfContent');
						if (!end) {
							return;
						}
						end.style.top = '';
						end.classList.remove('active');
					});
				}
			}]);
			return TextLayerBuilder;
		}();
		var DefaultTextLayerFactory = function() {
			function DefaultTextLayerFactory() {
				_classCallCheck(this, DefaultTextLayerFactory);
			}
			_createClass(DefaultTextLayerFactory, [{
				key: 'createTextLayerBuilder',
				value: function createTextLayerBuilder(textLayerDiv, pageIndex, viewport) {
					var enhanceTextSelection = arguments.length > 3 && arguments[3] !==
						undefined ? arguments[3] : false;
					return new TextLayerBuilder({
						textLayerDiv: textLayerDiv,
						pageIndex: pageIndex,
						viewport: viewport,
						enhanceTextSelection: enhanceTextSelection
					});
				}
			}]);
			return DefaultTextLayerFactory;
		}();
		exports.TextLayerBuilder = TextLayerBuilder;
		exports.DefaultTextLayerFactory = DefaultTextLayerFactory;
	}), /* 26 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.SecondaryToolbar = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdf_cursor_tools = __webpack_require__(6);
		var _ui_utils = __webpack_require__(0);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var SecondaryToolbar = function() {
			function SecondaryToolbar(options, mainContainer, eventBus) {
				_classCallCheck(this, SecondaryToolbar);
				this.toolbar = options.toolbar;
				this.toggleButton = options.toggleButton;
				this.toolbarButtonContainer = options.toolbarButtonContainer;
				this.buttons = [{
					element: options.presentationModeButton,
					eventName: 'presentationmode',
					close: true
				}, {
					element: options.openFileButton,
					eventName: 'openfile',
					close: true
				}, {
					element: options.printButton,
					eventName: 'print',
					close: true
				}, {
					element: options.downloadButton,
					eventName: 'download',
					close: true
				}, {
					element: options.viewBookmarkButton,
					eventName: null,
					close: true
				}, {
					element: options.firstPageButton,
					eventName: 'firstpage',
					close: true
				}, {
					element: options.lastPageButton,
					eventName: 'lastpage',
					close: true
				}, {
					element: options.pageRotateCwButton,
					eventName: 'rotatecw',
					close: false
				}, {
					element: options.pageRotateCcwButton,
					eventName: 'rotateccw',
					close: false
				}, {
					element: options.cursorSelectToolButton,
					eventName: 'switchcursortool',
					eventDetails: {
						tool: _pdf_cursor_tools.CursorTool.SELECT
					},
					close: true
				}, {
					element: options.cursorHandToolButton,
					eventName: 'switchcursortool',
					eventDetails: {
						tool: _pdf_cursor_tools.CursorTool.HAND
					},
					close: true
				}, {
					element: options.documentPropertiesButton,
					eventName: 'documentproperties',
					close: true
				}];
				this.items = {
					firstPage: options.firstPageButton,
					lastPage: options.lastPageButton,
					pageRotateCw: options.pageRotateCwButton,
					pageRotateCcw: options.pageRotateCcwButton
				};
				this.mainContainer = mainContainer;
				this.eventBus = eventBus;
				this.opened = false;
				this.containerHeight = null;
				this.previousContainerHeight = null;
				this.reset();
				this._bindClickListeners();
				this._bindCursorToolsListener(options);
				this.eventBus.on('resize', this._setMaxHeight.bind(this));
			}
			_createClass(SecondaryToolbar, [{
				key: 'setPageNumber',
				value: function setPageNumber(pageNumber) {
					this.pageNumber = pageNumber;
					this._updateUIState();
				}
			}, {
				key: 'setPagesCount',
				value: function setPagesCount(pagesCount) {
					this.pagesCount = pagesCount;
					this._updateUIState();
				}
			}, {
				key: 'reset',
				value: function reset() {
					this.pageNumber = 0;
					this.pagesCount = 0;
					this._updateUIState();
				}
			}, {
				key: '_updateUIState',
				value: function _updateUIState() {
					this.items.firstPage.disabled = this.pageNumber <= 1;
					this.items.lastPage.disabled = this.pageNumber >= this.pagesCount;
					this.items.pageRotateCw.disabled = this.pagesCount === 0;
					this.items.pageRotateCcw.disabled = this.pagesCount === 0;
				}
			}, {
				key: '_bindClickListeners',
				value: function _bindClickListeners() {
					var _this = this;
					this.toggleButton.addEventListener('click', this.toggle.bind(this));
					var _loop = function _loop(button) {
						var _buttons$button = _this.buttons[button],
							element = _buttons$button.element,
							eventName = _buttons$button.eventName,
							close = _buttons$button.close,
							eventDetails = _buttons$button.eventDetails;
						element.addEventListener('click', function(evt) {
							if (eventName !== null) {
								var details = {
									source: _this
								};
								for (var property in eventDetails) {
									details[property] = eventDetails[property];
								}
								_this.eventBus.dispatch(eventName, details);
							}
							if (close) {
								_this.close();
							}
						});
					};
					for (var button in this.buttons) {
						_loop(button);
					}
				}
			}, {
				key: '_bindCursorToolsListener',
				value: function _bindCursorToolsListener(buttons) {
					this.eventBus.on('cursortoolchanged', function(evt) {
						buttons.cursorSelectToolButton.classList.remove('toggled');
						buttons.cursorHandToolButton.classList.remove('toggled');
						switch (evt.tool) {
							case _pdf_cursor_tools.CursorTool.SELECT:
								buttons.cursorSelectToolButton.classList.add(
									'toggled');
								break;
							case _pdf_cursor_tools.CursorTool.HAND:
								buttons.cursorHandToolButton.classList.add(
									'toggled');
								break;
						}
					});
				}
			}, {
				key: 'open',
				value: function open() {
					if (this.opened) {
						return;
					}
					this.opened = true;
					this._setMaxHeight();
					this.toggleButton.classList.add('toggled');
					this.toolbar.classList.remove('hidden');
				}
			}, {
				key: 'close',
				value: function close() {
					if (!this.opened) {
						return;
					}
					this.opened = false;
					this.toolbar.classList.add('hidden');
					this.toggleButton.classList.remove('toggled');
				}
			}, {
				key: 'toggle',
				value: function toggle() {
					if (this.opened) {
						this.close();
					} else {
						this.open();
					}
				}
			}, {
				key: '_setMaxHeight',
				value: function _setMaxHeight() {
					if (!this.opened) {
						return;
					}
					this.containerHeight = this.mainContainer.clientHeight;
					if (this.containerHeight === this.previousContainerHeight) {
						return;
					}
					this.toolbarButtonContainer.setAttribute('style', 'max-height: ' + (this
						.containerHeight - _ui_utils.SCROLLBAR_PADDING) + 'px;');
					this.previousContainerHeight = this.containerHeight;
				}
			}, {
				key: 'isOpen',
				get: function get() {
					return this.opened;
				}
			}]);
			return SecondaryToolbar;
		}();
		exports.SecondaryToolbar = SecondaryToolbar;
	}), /* 27 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.Toolbar = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var PAGE_NUMBER_LOADING_INDICATOR = 'visiblePageIsLoading';
		var SCALE_SELECT_CONTAINER_PADDING = 8;
		var SCALE_SELECT_PADDING = 22;
		var Toolbar = function() {
			function Toolbar(options, mainContainer, eventBus) {
				var l10n = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : _ui_utils
					.NullL10n;
				_classCallCheck(this, Toolbar);
				this.toolbar = options.container;
				this.mainContainer = mainContainer;
				this.eventBus = eventBus;
				this.l10n = l10n;
				this.items = options;
				this._wasLocalized = false;
				this.reset();
				this._bindListeners();
			}
			_createClass(Toolbar, [{
				key: 'setPageNumber',
				value: function setPageNumber(pageNumber, pageLabel) {
					this.pageNumber = pageNumber;
					this.pageLabel = pageLabel;
					this._updateUIState(false);
				}
			}, {
				key: 'setPagesCount',
				value: function setPagesCount(pagesCount, hasPageLabels) {
					this.pagesCount = pagesCount;
					this.hasPageLabels = hasPageLabels;
					this._updateUIState(true);
				}
			}, {
				key: 'setPageScale',
				value: function setPageScale(pageScaleValue, pageScale) {
					this.pageScaleValue = pageScaleValue;
					this.pageScale = pageScale;
					this._updateUIState(false);
				}
			}, {
				key: 'reset',
				value: function reset() {
					this.pageNumber = 0;
					this.pageLabel = null;
					this.hasPageLabels = false;
					this.pagesCount = 0;
					this.pageScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
					this.pageScale = _ui_utils.DEFAULT_SCALE;
					this._updateUIState(true);
				}
			}, {
				key: '_bindListeners',
				value: function _bindListeners() {
					var _this = this;
					var eventBus = this.eventBus,
						items = this.items;
					var self = this;
					items.previous.addEventListener('click', function() {
						eventBus.dispatch('previouspage');
					});
					items.next.addEventListener('click', function() {
						eventBus.dispatch('nextpage');
					});
					items.zoomIn.addEventListener('click', function() {
						eventBus.dispatch('zoomin');
					});
					items.zoomOut.addEventListener('click', function() {
						eventBus.dispatch('zoomout');
					});
					items.pageNumber.addEventListener('click', function() {
						this.select();
					});
					items.pageNumber.addEventListener('change', function() {
						eventBus.dispatch('pagenumberchanged', {
							source: self,
							value: this.value
						});
					});
					items.scaleSelect.addEventListener('change', function() {
						if (this.value === 'custom') {
							return;
						}
						eventBus.dispatch('scalechanged', {
							source: self,
							value: this.value
						});
					});
					items.presentationModeButton.addEventListener('click', function() {
						eventBus.dispatch('presentationmode');
					});
					items.openFile.addEventListener('click', function() {
						eventBus.dispatch('openfile');
					});
					items.print.addEventListener('click', function() {
						eventBus.dispatch('print');
					});
					items.download.addEventListener('click', function() {
						eventBus.dispatch('download');
					});
					items.scaleSelect.oncontextmenu = _ui_utils.noContextMenuHandler;
					eventBus.on('localized', function() {
						_this._localized();
					});
				}
			}, {
				key: '_localized',
				value: function _localized() {
					this._wasLocalized = true;
					this._adjustScaleWidth();
					this._updateUIState(true);
				}
			}, {
				key: '_updateUIState',
				value: function _updateUIState() {
					var resetNumPages = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : false;
					if (!this._wasLocalized) {
						return;
					}
					var pageNumber = this.pageNumber,
						pagesCount = this.pagesCount,
						items = this.items;
					var scaleValue = (this.pageScaleValue || this.pageScale).toString();
					var scale = this.pageScale;
					if (resetNumPages) {
						if (this.hasPageLabels) {
							items.pageNumber.type = 'text';
						} else {
							items.pageNumber.type = 'number';
							this.l10n.get('of_pages', {
								pagesCount: pagesCount
							}, 'of {{pagesCount}}').then(function(msg) {
								items.numPages.textContent = msg;
							});
						}
						items.pageNumber.max = pagesCount;
					}
					if (this.hasPageLabels) {
						items.pageNumber.value = this.pageLabel;
						this.l10n.get('page_of_pages', {
							pageNumber: pageNumber,
							pagesCount: pagesCount
						}, '({{pageNumber}} of {{pagesCount}})').then(function(msg) {
							items.numPages.textContent = msg;
						});
					} else {
						items.pageNumber.value = pageNumber;
					}
					items.previous.disabled = pageNumber <= 1;
					items.next.disabled = pageNumber >= pagesCount;
					items.zoomOut.disabled = scale <= _ui_utils.MIN_SCALE;
					items.zoomIn.disabled = scale >= _ui_utils.MAX_SCALE;
					var customScale = Math.round(scale * 10000) / 100;
					this.l10n.get('page_scale_percent', {
						scale: customScale
					}, '{{scale}}%').then(function(msg) {
						var options = items.scaleSelect.options;
						var predefinedValueFound = false;
						for (var i = 0, ii = options.length; i < ii; i++) {
							var option = options[i];
							if (option.value !== scaleValue) {
								option.selected = false;
								continue;
							}
							option.selected = true;
							predefinedValueFound = true;
						}
						if (!predefinedValueFound) {
							items.customScaleOption.textContent = msg;
							items.customScaleOption.selected = true;
						}
					});
				}
			}, {
				key: 'updateLoadingIndicatorState',
				value: function updateLoadingIndicatorState() {
					var loading = arguments.length > 0 && arguments[0] !== undefined ?
						arguments[0] : false;
					var pageNumberInput = this.items.pageNumber;
					if (loading) {
						pageNumberInput.classList.add(PAGE_NUMBER_LOADING_INDICATOR);
					} else {
						pageNumberInput.classList.remove(PAGE_NUMBER_LOADING_INDICATOR);
					}
				}
			}, {
				key: '_adjustScaleWidth',
				value: function _adjustScaleWidth() {
					var container = this.items.scaleSelectContainer;
					var select = this.items.scaleSelect;
					_ui_utils.animationStarted.then(function() {
						if (container.clientWidth === 0) {
							container.setAttribute('style', 'display: inherit;');
						}
						if (container.clientWidth > 0) {
							select.setAttribute('style', 'min-width: inherit;');
							var width = select.clientWidth +
								SCALE_SELECT_CONTAINER_PADDING;
							select.setAttribute('style', 'min-width: ' + (width +
								SCALE_SELECT_PADDING) + 'px;');
							container.setAttribute('style', 'min-width: ' + width +
								'px; ' + 'max-width: ' + width + 'px;');
						}
					});
				}
			}]);
			return Toolbar;
		}();
		exports.Toolbar = Toolbar;
	}), /* 28 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var DEFAULT_VIEW_HISTORY_CACHE_SIZE = 20;
		var ViewHistory = function() {
			function ViewHistory(fingerprint) {
				var _this = this;
				var cacheSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] :
					DEFAULT_VIEW_HISTORY_CACHE_SIZE;
				_classCallCheck(this, ViewHistory);
				this.fingerprint = fingerprint;
				this.cacheSize = cacheSize;
				this._initializedPromise = this._readFromStorage().then(function(databaseStr) {
					var database = JSON.parse(databaseStr || '{}');
					if (!('files' in database)) {
						database.files = [];
					}
					if (database.files.length >= _this.cacheSize) {
						database.files.shift();
					}
					var index = void 0;
					for (var i = 0, length = database.files.length; i < length; i++) {
						var branch = database.files[i];
						if (branch.fingerprint === _this.fingerprint) {
							index = i;
							break;
						}
					}
					if (typeof index !== 'number') {
						index = database.files.push({
							fingerprint: _this.fingerprint
						}) - 1;
					}
					_this.file = database.files[index];
					_this.database = database;
				});
			}
			_createClass(ViewHistory, [{
				key: '_writeToStorage',
				value: function _writeToStorage() {
					var _this2 = this;
					return new Promise(function(resolve) {
						var databaseStr = JSON.stringify(_this2.database);
						localStorage.setItem('pdfjs.history', databaseStr);
						resolve();
					});
				}
			}, {
				key: '_readFromStorage',
				value: function _readFromStorage() {
					return new Promise(function(resolve) {
						resolve(localStorage.getItem('pdfjs.history'));
					});
				}
			}, {
				key: 'set',
				value: function set(name, val) {
					var _this3 = this;
					return this._initializedPromise.then(function() {
						_this3.file[name] = val;
						return _this3._writeToStorage();
					});
				}
			}, {
				key: 'setMultiple',
				value: function setMultiple(properties) {
					var _this4 = this;
					return this._initializedPromise.then(function() {
						for (var name in properties) {
							_this4.file[name] = properties[name];
						}
						return _this4._writeToStorage();
					});
				}
			}, {
				key: 'get',
				value: function get(name, defaultValue) {
					var _this5 = this;
					return this._initializedPromise.then(function() {
						var val = _this5.file[name];
						return val !== undefined ? val : defaultValue;
					});
				}
			}, {
				key: 'getMultiple',
				value: function getMultiple(properties) {
					var _this6 = this;
					return this._initializedPromise.then(function() {
						var values = Object.create(null);
						for (var name in properties) {
							var val = _this6.file[name];
							values[name] = val !== undefined ? val : properties[
								name];
						}
						return values;
					});
				}
			}]);
			return ViewHistory;
		}();
		exports.ViewHistory = ViewHistory;
	}), /* 29 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.GenericCom = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _app = __webpack_require__(4);
		var _preferences = __webpack_require__(30);
		var _download_manager = __webpack_require__(31);
		var _genericl10n = __webpack_require__(32);
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}

		function _possibleConstructorReturn(self, call) {
			if (!self) {
				throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
			}
			return call && (typeof call === "object" || typeof call === "function") ? call : self;
		}

		function _inherits(subClass, superClass) {
			if (typeof superClass !== "function" && superClass !== null) {
				throw new TypeError("Super expression must either be null or a function, not " +
					typeof superClass);
			}
			subClass.prototype = Object.create(superClass && superClass.prototype, {
				constructor: {
					value: subClass,
					enumerable: false,
					writable: true,
					configurable: true
				}
			});
			if (superClass)
				Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ =
				superClass;
		};
		var GenericCom = {};
		var GenericPreferences = function(_BasePreferences) {
			_inherits(GenericPreferences, _BasePreferences);

			function GenericPreferences() {
				_classCallCheck(this, GenericPreferences);
				return _possibleConstructorReturn(this, (GenericPreferences.__proto__ || Object
					.getPrototypeOf(GenericPreferences)).apply(this, arguments));
			}
			_createClass(GenericPreferences, [{
				key: '_writeToStorage',
				value: function _writeToStorage(prefObj) {
					return new Promise(function(resolve) {
						localStorage.setItem('pdfjs.preferences', JSON.stringify(
							prefObj));
						resolve();
					});
				}
			}, {
				key: '_readFromStorage',
				value: function _readFromStorage(prefObj) {
					return new Promise(function(resolve) {
						var readPrefs = JSON.parse(localStorage.getItem(
							'pdfjs.preferences'));
						resolve(readPrefs);
					});
				}
			}]);
			return GenericPreferences;
		}(_preferences.BasePreferences);
		var GenericExternalServices = Object.create(_app.DefaultExternalServices);
		GenericExternalServices.createDownloadManager = function() {
			return new _download_manager.DownloadManager();
		};
		GenericExternalServices.createPreferences = function() {
			return new GenericPreferences();
		};
		GenericExternalServices.createL10n = function() {
			return new _genericl10n.GenericL10n(_pdfjsLib.PDFJS.locale);
		};
		_app.PDFViewerApplication.externalServices = GenericExternalServices;
		exports.GenericCom = GenericCom;
	}), /* 30 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.BasePreferences = undefined;
		var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
				return typeof obj;
			} :
			function(obj) {
				return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol
					.prototype ? "symbol" : typeof obj;
			};
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _ui_utils = __webpack_require__(0);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var defaultPreferences = null;

		function getDefaultPreferences() {
			if (!defaultPreferences) {
				defaultPreferences = Promise.resolve({
					"showPreviousViewOnLoad": true,
					"defaultZoomValue": "",
					"sidebarViewOnLoad": 0,
					"enableHandToolOnLoad": false,
					"cursorToolOnLoad": 0,
					"enableWebGL": false,
					"pdfBugEnabled": false,
					"disableRange": false,
					"disableStream": false,
					"disableAutoFetch": false,
					"disableFontFace": false,
					"disableTextLayer": false,
					"useOnlyCssZoom": false,
					"externalLinkTarget": 0,
					"enhanceTextSelection": false,
					"renderer": "canvas",
					"renderInteractiveForms": false,
					"enablePrintAutoRotate": false,
					"disablePageMode": false,
					"disablePageLabels": false
				});
			}
			return defaultPreferences;
		}
		var BasePreferences = function() {
			function BasePreferences() {
				var _this = this;
				_classCallCheck(this, BasePreferences);
				if (this.constructor === BasePreferences) {
					throw new Error('Cannot initialize BasePreferences.');
				}
				this.prefs = null;
				this._initializedPromise = getDefaultPreferences().then(function(defaults) {
					Object.defineProperty(_this, 'defaults', {
						value: Object.freeze(defaults),
						writable: false,
						enumerable: true,
						configurable: false
					});
					_this.prefs = (0,
						_ui_utils.cloneObj)(defaults);
					return _this._readFromStorage(defaults);
				}).then(function(prefObj) {
					if (prefObj) {
						_this.prefs = prefObj;
					}
				});
			}
			_createClass(BasePreferences, [{
				key: "_writeToStorage",
				value: function _writeToStorage(prefObj) {
					return Promise.reject(new Error('Not implemented: _writeToStorage'));
				}
			}, {
				key: "_readFromStorage",
				value: function _readFromStorage(prefObj) {
					return Promise.reject(new Error('Not implemented: _readFromStorage'));
				}
			}, {
				key: "reset",
				value: function reset() {
					var _this2 = this;
					return this._initializedPromise.then(function() {
						_this2.prefs = (0,
							_ui_utils.cloneObj)(_this2.defaults);
						return _this2._writeToStorage(_this2.defaults);
					});
				}
			}, {
				key: "reload",
				value: function reload() {
					var _this3 = this;
					return this._initializedPromise.then(function() {
						return _this3._readFromStorage(_this3.defaults);
					}).then(function(prefObj) {
						if (prefObj) {
							_this3.prefs = prefObj;
						}
					});
				}
			}, {
				key: "set",
				value: function set(name, value) {
					var _this4 = this;
					return this._initializedPromise.then(function() {
						if (_this4.defaults[name] === undefined) {
							throw new Error("Set preference: \"" + name +
								"\" is undefined.");
						} else if (value === undefined) {
							throw new Error(
								'Set preference: no value is specified.');
						}
						var valueType = typeof value === "undefined" ? "undefined" :
							_typeof(value);
						var defaultType = _typeof(_this4.defaults[name]);
						if (valueType !== defaultType) {
							if (valueType === 'number' && defaultType ===
								'string') {
								value = value.toString();
							} else {
								throw new Error("Set preference: \"" + value +
									"\" is a " + valueType + ", " + (
										"expected a " + defaultType + "."));
							}
						} else {
							if (valueType === 'number' && !Number.isInteger(
								value)) {
								throw new Error("Set preference: \"" + value +
									"\" must be an integer.");
							}
						}
						_this4.prefs[name] = value;
						return _this4._writeToStorage(_this4.prefs);
					});
				}
			}, {
				key: "get",
				value: function get(name) {
					var _this5 = this;
					return this._initializedPromise.then(function() {
						var defaultValue = _this5.defaults[name];
						if (defaultValue === undefined) {
							throw new Error("Get preference: \"" + name +
								"\" is undefined.");
						} else {
							var prefValue = _this5.prefs[name];
							if (prefValue !== undefined) {
								return prefValue;
							}
						}
						return defaultValue;
					});
				}
			}]);
			return BasePreferences;
		}();
		exports.BasePreferences = BasePreferences;
	}), /* 31 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.DownloadManager = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		var _pdfjsLib = __webpack_require__(1);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		};

		function _download(blobUrl, filename) {
			var a = document.createElement('a');
			if (a.click) {
				a.href = blobUrl;
				a.target = '_parent';
				if ('download' in a) {
					a.download = filename;
				}
				(document.body || document.documentElement).appendChild(a);
				a.click();
				a.parentNode.removeChild(a);
			} else {
				if (window.top === window && blobUrl.split('#')[0] === window.location.href.split('#')[0]) {
					var padCharacter = blobUrl.indexOf('?') === -1 ? '?' : '&';
					blobUrl = blobUrl.replace(/#|$/, padCharacter + '$&');
				}
				window.open(blobUrl, '_parent');
			}
		}
		var DownloadManager = function() {
			function DownloadManager() {
				_classCallCheck(this, DownloadManager);
			}
			_createClass(DownloadManager, [{
				key: 'downloadUrl',
				value: function downloadUrl(url, filename) {
					if (!(0,
							_pdfjsLib.createValidAbsoluteUrl)(url, 'http://example.com')) {
						return;
					}
					_download(url + '#pdfjs.action=download', filename);
				}
			}, {
				key: 'downloadData',
				value: function downloadData(data, filename, contentType) {
					if (navigator.msSaveBlob) {
						return navigator.msSaveBlob(new Blob([data], {
							type: contentType
						}), filename);
					}
					var blobUrl = (0,
						_pdfjsLib.createObjectURL)(data, contentType, _pdfjsLib.PDFJS
						.disableCreateObjectURL);
					_download(blobUrl, filename);
				}
			}, {
				key: 'download',
				value: function download(blob, url, filename) {
					if (navigator.msSaveBlob) {
						if (!navigator.msSaveBlob(blob, filename)) {
							this.downloadUrl(url, filename);
						}
						return;
					}
					if (_pdfjsLib.PDFJS.disableCreateObjectURL) {
						this.downloadUrl(url, filename);
						return;
					}
					var blobUrl = URL.createObjectURL(blob);
					_download(blobUrl, filename);
				}
			}]);
			return DownloadManager;
		}();
		exports.DownloadManager = DownloadManager;
	}), /* 32 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.GenericL10n = undefined;
		var _createClass = function() {
			function defineProperties(target, props) {
				for (var i = 0; i < props.length; i++) {
					var descriptor = props[i];
					descriptor.enumerable = descriptor.enumerable || false;
					descriptor.configurable = true;
					if ("value" in descriptor)
						descriptor.writable = true;
					Object.defineProperty(target, descriptor.key, descriptor);
				}
			}
			return function(Constructor, protoProps, staticProps) {
				if (protoProps)
					defineProperties(Constructor.prototype, protoProps);
				if (staticProps)
					defineProperties(Constructor, staticProps);
				return Constructor;
			};
		}();
		__webpack_require__(33);

		function _classCallCheck(instance, Constructor) {
			if (!(instance instanceof Constructor)) {
				throw new TypeError("Cannot call a class as a function");
			}
		}
		var webL10n = document.webL10n;
		var GenericL10n = function() {
			function GenericL10n(lang) {
				_classCallCheck(this, GenericL10n);
				this._lang = lang;
				this._ready = new Promise(function(resolve, reject) {
					webL10n.setLanguage(lang, function() {
						resolve(webL10n);
					});
				});
			}
			_createClass(GenericL10n, [{
				key: 'getDirection',
				value: function getDirection() {
					return this._ready.then(function(l10n) {
						return l10n.getDirection();
					});
				}
			}, {
				key: 'get',
				value: function get(property, args, fallback) {
					return this._ready.then(function(l10n) {
						return l10n.get(property, args, fallback);
					});
				}
			}, {
				key: 'translate',
				value: function translate(element) {
					return this._ready.then(function(l10n) {
						return l10n.translate(element);
					});
				}
			}]);
			return GenericL10n;
		}();
		exports.GenericL10n = GenericL10n;
	}), /* 33 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		document.webL10n = function(window, document, undefined) {
			var gL10nData = {};
			var gTextData = '';
			var gTextProp = 'textContent';
			var gLanguage = '';
			var gMacros = {};
			var gReadyState = 'loading';
			var gAsyncResourceLoading = true;

			function getL10nResourceLinks() {
				return document.querySelectorAll('link[type="application/l10n"]');
			}

			function getL10nDictionary() {
				var script = document.querySelector('script[type="application/l10n"]');
				return script ? JSON.parse(script.innerHTML) : null;
			}

			function getTranslatableChildren(element) {
				return element ? element.querySelectorAll('*[data-l10n-id]') : [];
			}

			function getL10nAttributes(element) {
				if (!element)
					return {};
				var l10nId = element.getAttribute('data-l10n-id');
				var l10nArgs = element.getAttribute('data-l10n-args');
				var args = {};
				if (l10nArgs) {
					try {
						args = JSON.parse(l10nArgs);
					} catch (e) {
						console.warn('could not parse arguments for #' + l10nId);
					}
				}
				return {
					id: l10nId,
					args: args
				};
			}

			function fireL10nReadyEvent(lang) {
				var evtObject = document.createEvent('Event');
				evtObject.initEvent('localized', true, false);
				evtObject.language = lang;
				document.dispatchEvent(evtObject);
			}

			function xhrLoadText(url, onSuccess, onFailure) {
				onSuccess = onSuccess || function _onSuccess(data) {};
				onFailure = onFailure || function _onFailure() {};
				var xhr = new XMLHttpRequest();
				xhr.open('GET', url, gAsyncResourceLoading);
				if (xhr.overrideMimeType) {
					xhr.overrideMimeType('text/plain; charset=utf-8');
				}
				xhr.onreadystatechange = function() {
					if (xhr.readyState == 4) {
						if (xhr.status == 200 || xhr.status === 0) {
							onSuccess(xhr.responseText);
						} else {
							onFailure();
						}
					}
				};
				xhr.onerror = onFailure;
				xhr.ontimeout = onFailure;
				try {
					xhr.send(null);
				} catch (e) {
					onFailure();
				}
			}

			function parseResource(href, lang, successCallback, failureCallback) {
				var baseURL = href.replace(/[^\/]*$/, '') || './';

				function evalString(text) {
					if (text.lastIndexOf('\\') < 0)
						return text;
					return text.replace(/\\\\/g, '\\').replace(/\\n/g, '\n').replace(/\\r/g, '\r').replace(
							/\\t/g, '\t').replace(/\\b/g, '\b').replace(/\\f/g, '\f').replace(/\\{/g, '{')
						.replace(/\\}/g, '}').replace(/\\"/g, '"').replace(/\\'/g, "'");
				}

				function parseProperties(text, parsedPropertiesCallback) {
					var dictionary = {};
					var reBlank = /^\s*|\s*$/;
					var reComment = /^\s*#|^\s*$/;
					var reSection = /^\s*\[(.*)\]\s*$/;
					var reImport = /^\s*@import\s+url\((.*)\)\s*$/i;
					var reSplit = /^([^=\s]*)\s*=\s*(.+)$/;

					function parseRawLines(rawText, extendedSyntax, parsedRawLinesCallback) {
						var entries = rawText.replace(reBlank, '').split(/[\r\n]+/);
						var currentLang = '*';
						var genericLang = lang.split('-', 1)[0];
						var skipLang = false;
						var match = '';

						function nextEntry() {
							while (true) {
								if (!entries.length) {
									parsedRawLinesCallback();
									return;
								}
								var line = entries.shift();
								if (reComment.test(line))
									continue;
								if (extendedSyntax) {
									match = reSection.exec(line);
									if (match) {
										currentLang = match[1].toLowerCase();
										skipLang = currentLang !== '*' && currentLang !== lang &&
											currentLang !== genericLang;
										continue;
									} else if (skipLang) {
										continue;
									}
									match = reImport.exec(line);
									if (match) {
										loadImport(baseURL + match[1], nextEntry);
										return;
									}
								}
								var tmp = line.match(reSplit);
								if (tmp && tmp.length == 3) {
									dictionary[tmp[1]] = evalString(tmp[2]);
								}
							}
						}
						nextEntry();
					}

					function loadImport(url, callback) {
						xhrLoadText(url, function(content) {
							parseRawLines(content, false, callback);
						}, function() {
							console.warn(url + ' not found.');
							callback();
						});
					}
					parseRawLines(text, true, function() {
						parsedPropertiesCallback(dictionary);
					});
				}
				xhrLoadText(href, function(response) {
					gTextData += response;
					parseProperties(response, function(data) {
						for (var key in data) {
							var id, prop, index = key.lastIndexOf('.');
							if (index > 0) {
								id = key.substring(0, index);
								prop = key.substr(index + 1);
							} else {
								id = key;
								prop = gTextProp;
							}
							if (!gL10nData[id]) {
								gL10nData[id] = {};
							}
							gL10nData[id][prop] = data[key];
						}
						if (successCallback) {
							successCallback();
						}
					});
				}, failureCallback);
			}

			function loadLocale(lang, callback) {
				if (lang) {
					lang = lang.toLowerCase();
				}
				callback = callback || function _callback() {};
				clear();
				gLanguage = lang;
				var langLinks = getL10nResourceLinks();
				var langCount = langLinks.length;
				if (langCount === 0) {
					var dict = getL10nDictionary();
					if (dict && dict.locales && dict.default_locale) {
						console.log('using the embedded JSON directory, early way out');
						gL10nData = dict.locales[lang];
						if (!gL10nData) {
							var defaultLocale = dict.default_locale.toLowerCase();
							for (var anyCaseLang in dict.locales) {
								anyCaseLang = anyCaseLang.toLowerCase();
								if (anyCaseLang === lang) {
									gL10nData = dict.locales[lang];
									break;
								} else if (anyCaseLang === defaultLocale) {
									gL10nData = dict.locales[defaultLocale];
								}
							}
						}
						callback();
					} else {
						console.log('no resource to load, early way out');
					}
					fireL10nReadyEvent(lang);
					gReadyState = 'complete';
					return;
				}
				var onResourceLoaded = null;
				var gResourceCount = 0;
				onResourceLoaded = function onResourceLoaded() {
					gResourceCount++;
					if (gResourceCount >= langCount) {
						callback();
						fireL10nReadyEvent(lang);
						gReadyState = 'complete';
					}
				};

				function L10nResourceLink(link) {
					var href = link.href;
					this.load = function(lang, callback) {
						parseResource(href, lang, callback, function() {
							console.warn(href + ' not found.');
							console.warn('"' + lang + '" resource not found');
							gLanguage = '';
							callback();
						});
					};
				}
				for (var i = 0; i < langCount; i++) {
					var resource = new L10nResourceLink(langLinks[i]);
					resource.load(lang, onResourceLoaded);
				}
			}

			function clear() {
				gL10nData = {};
				gTextData = '';
				gLanguage = '';
			}

			function getPluralRules(lang) {
				var locales2rules = {
					'af': 3,
					'ak': 4,
					'am': 4,
					'ar': 1,
					'asa': 3,
					'az': 0,
					'be': 11,
					'bem': 3,
					'bez': 3,
					'bg': 3,
					'bh': 4,
					'bm': 0,
					'bn': 3,
					'bo': 0,
					'br': 20,
					'brx': 3,
					'bs': 11,
					'ca': 3,
					'cgg': 3,
					'chr': 3,
					'cs': 12,
					'cy': 17,
					'da': 3,
					'de': 3,
					'dv': 3,
					'dz': 0,
					'ee': 3,
					'el': 3,
					'en': 3,
					'eo': 3,
					'es': 3,
					'et': 3,
					'eu': 3,
					'fa': 0,
					'ff': 5,
					'fi': 3,
					'fil': 4,
					'fo': 3,
					'fr': 5,
					'fur': 3,
					'fy': 3,
					'ga': 8,
					'gd': 24,
					'gl': 3,
					'gsw': 3,
					'gu': 3,
					'guw': 4,
					'gv': 23,
					'ha': 3,
					'haw': 3,
					'he': 2,
					'hi': 4,
					'hr': 11,
					'hu': 0,
					'id': 0,
					'ig': 0,
					'ii': 0,
					'is': 3,
					'it': 3,
					'iu': 7,
					'ja': 0,
					'jmc': 3,
					'jv': 0,
					'ka': 0,
					'kab': 5,
					'kaj': 3,
					'kcg': 3,
					'kde': 0,
					'kea': 0,
					'kk': 3,
					'kl': 3,
					'km': 0,
					'kn': 0,
					'ko': 0,
					'ksb': 3,
					'ksh': 21,
					'ku': 3,
					'kw': 7,
					'lag': 18,
					'lb': 3,
					'lg': 3,
					'ln': 4,
					'lo': 0,
					'lt': 10,
					'lv': 6,
					'mas': 3,
					'mg': 4,
					'mk': 16,
					'ml': 3,
					'mn': 3,
					'mo': 9,
					'mr': 3,
					'ms': 0,
					'mt': 15,
					'my': 0,
					'nah': 3,
					'naq': 7,
					'nb': 3,
					'nd': 3,
					'ne': 3,
					'nl': 3,
					'nn': 3,
					'no': 3,
					'nr': 3,
					'nso': 4,
					'ny': 3,
					'nyn': 3,
					'om': 3,
					'or': 3,
					'pa': 3,
					'pap': 3,
					'pl': 13,
					'ps': 3,
					'pt': 3,
					'rm': 3,
					'ro': 9,
					'rof': 3,
					'ru': 11,
					'rwk': 3,
					'sah': 0,
					'saq': 3,
					'se': 7,
					'seh': 3,
					'ses': 0,
					'sg': 0,
					'sh': 11,
					'shi': 19,
					'sk': 12,
					'sl': 14,
					'sma': 7,
					'smi': 7,
					'smj': 7,
					'smn': 7,
					'sms': 7,
					'sn': 3,
					'so': 3,
					'sq': 3,
					'sr': 11,
					'ss': 3,
					'ssy': 3,
					'st': 3,
					'sv': 3,
					'sw': 3,
					'syr': 3,
					'ta': 3,
					'te': 3,
					'teo': 3,
					'th': 0,
					'ti': 4,
					'tig': 3,
					'tk': 3,
					'tl': 4,
					'tn': 3,
					'to': 0,
					'tr': 0,
					'ts': 3,
					'tzm': 22,
					'uk': 11,
					'ur': 3,
					've': 3,
					'vi': 0,
					'vun': 3,
					'wa': 4,
					'wae': 3,
					'wo': 0,
					'xh': 3,
					'xog': 3,
					'yo': 0,
					'zh': 0,
					'zu': 3
				};

				function isIn(n, list) {
					return list.indexOf(n) !== -1;
				}

				function isBetween(n, start, end) {
					return start <= n && n <= end;
				}
				var pluralRules = {
					'0': function _(n) {
						return 'other';
					},
					'1': function _(n) {
						if (isBetween(n % 100, 3, 10))
							return 'few';
						if (n === 0)
							return 'zero';
						if (isBetween(n % 100, 11, 99))
							return 'many';
						if (n == 2)
							return 'two';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'2': function _(n) {
						if (n !== 0 && n % 10 === 0)
							return 'many';
						if (n == 2)
							return 'two';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'3': function _(n) {
						if (n == 1)
							return 'one';
						return 'other';
					},
					'4': function _(n) {
						if (isBetween(n, 0, 1))
							return 'one';
						return 'other';
					},
					'5': function _(n) {
						if (isBetween(n, 0, 2) && n != 2)
							return 'one';
						return 'other';
					},
					'6': function _(n) {
						if (n === 0)
							return 'zero';
						if (n % 10 == 1 && n % 100 != 11)
							return 'one';
						return 'other';
					},
					'7': function _(n) {
						if (n == 2)
							return 'two';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'8': function _(n) {
						if (isBetween(n, 3, 6))
							return 'few';
						if (isBetween(n, 7, 10))
							return 'many';
						if (n == 2)
							return 'two';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'9': function _(n) {
						if (n === 0 || n != 1 && isBetween(n % 100, 1, 19))
							return 'few';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'10': function _(n) {
						if (isBetween(n % 10, 2, 9) && !isBetween(n % 100, 11, 19))
							return 'few';
						if (n % 10 == 1 && !isBetween(n % 100, 11, 19))
							return 'one';
						return 'other';
					},
					'11': function _(n) {
						if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14))
							return 'few';
						if (n % 10 === 0 || isBetween(n % 10, 5, 9) || isBetween(n % 100, 11, 14))
							return 'many';
						if (n % 10 == 1 && n % 100 != 11)
							return 'one';
						return 'other';
					},
					'12': function _(n) {
						if (isBetween(n, 2, 4))
							return 'few';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'13': function _(n) {
						if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14))
							return 'few';
						if (n != 1 && isBetween(n % 10, 0, 1) || isBetween(n % 10, 5, 9) ||
							isBetween(n % 100, 12, 14))
							return 'many';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'14': function _(n) {
						if (isBetween(n % 100, 3, 4))
							return 'few';
						if (n % 100 == 2)
							return 'two';
						if (n % 100 == 1)
							return 'one';
						return 'other';
					},
					'15': function _(n) {
						if (n === 0 || isBetween(n % 100, 2, 10))
							return 'few';
						if (isBetween(n % 100, 11, 19))
							return 'many';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'16': function _(n) {
						if (n % 10 == 1 && n != 11)
							return 'one';
						return 'other';
					},
					'17': function _(n) {
						if (n == 3)
							return 'few';
						if (n === 0)
							return 'zero';
						if (n == 6)
							return 'many';
						if (n == 2)
							return 'two';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'18': function _(n) {
						if (n === 0)
							return 'zero';
						if (isBetween(n, 0, 2) && n !== 0 && n != 2)
							return 'one';
						return 'other';
					},
					'19': function _(n) {
						if (isBetween(n, 2, 10))
							return 'few';
						if (isBetween(n, 0, 1))
							return 'one';
						return 'other';
					},
					'20': function _(n) {
						if ((isBetween(n % 10, 3, 4) || n % 10 == 9) && !(isBetween(n % 100, 10,
								19) || isBetween(n % 100, 70, 79) || isBetween(n % 100, 90, 99)))
							return 'few';
						if (n % 1000000 === 0 && n !== 0)
							return 'many';
						if (n % 10 == 2 && !isIn(n % 100, [12, 72, 92]))
							return 'two';
						if (n % 10 == 1 && !isIn(n % 100, [11, 71, 91]))
							return 'one';
						return 'other';
					},
					'21': function _(n) {
						if (n === 0)
							return 'zero';
						if (n == 1)
							return 'one';
						return 'other';
					},
					'22': function _(n) {
						if (isBetween(n, 0, 1) || isBetween(n, 11, 99))
							return 'one';
						return 'other';
					},
					'23': function _(n) {
						if (isBetween(n % 10, 1, 2) || n % 20 === 0)
							return 'one';
						return 'other';
					},
					'24': function _(n) {
						if (isBetween(n, 3, 10) || isBetween(n, 13, 19))
							return 'few';
						if (isIn(n, [2, 12]))
							return 'two';
						if (isIn(n, [1, 11]))
							return 'one';
						return 'other';
					}
				};
				var index = locales2rules[lang.replace(/-.*$/, '')];
				if (!(index in pluralRules)) {
					console.warn('plural form unknown for [' + lang + ']');
					return function() {
						return 'other';
					};
				}
				return pluralRules[index];
			}
			gMacros.plural = function(str, param, key, prop) {
				var n = parseFloat(param);
				if (isNaN(n))
					return str;
				if (prop != gTextProp)
					return str;
				if (!gMacros._pluralRules) {
					gMacros._pluralRules = getPluralRules(gLanguage);
				}
				var index = '[' + gMacros._pluralRules(n) + ']';
				if (n === 0 && key + '[zero]' in gL10nData) {
					str = gL10nData[key + '[zero]'][prop];
				} else if (n == 1 && key + '[one]' in gL10nData) {
					str = gL10nData[key + '[one]'][prop];
				} else if (n == 2 && key + '[two]' in gL10nData) {
					str = gL10nData[key + '[two]'][prop];
				} else if (key + index in gL10nData) {
					str = gL10nData[key + index][prop];
				} else if (key + '[other]' in gL10nData) {
					str = gL10nData[key + '[other]'][prop];
				}
				return str;
			};

			function getL10nData(key, args, fallback) {
				var data = gL10nData[key];
				if (!data) {
					console.warn('#' + key + ' is undefined.');
					if (!fallback) {
						return null;
					}
					data = fallback;
				}
				var rv = {};
				for (var prop in data) {
					var str = data[prop];
					str = substIndexes(str, args, key, prop);
					str = substArguments(str, args, key);
					rv[prop] = str;
				}
				return rv;
			}

			function substIndexes(str, args, key, prop) {
				var reIndex = /\{\[\s*([a-zA-Z]+)\(([a-zA-Z]+)\)\s*\]\}/;
				var reMatch = reIndex.exec(str);
				if (!reMatch || !reMatch.length)
					return str;
				var macroName = reMatch[1];
				var paramName = reMatch[2];
				var param;
				if (args && paramName in args) {
					param = args[paramName];
				} else if (paramName in gL10nData) {
					param = gL10nData[paramName];
				}
				if (macroName in gMacros) {
					var macro = gMacros[macroName];
					str = macro(str, param, key, prop);
				}
				return str;
			}

			function substArguments(str, args, key) {
				var reArgs = /\{\{\s*(.+?)\s*\}\}/g;
				return str.replace(reArgs, function(matched_text, arg) {
					if (args && arg in args) {
						return args[arg];
					}
					if (arg in gL10nData) {
						return gL10nData[arg];
					}
					console.log('argument {{' + arg + '}} for #' + key + ' is undefined.');
					return matched_text;
				});
			}

			function translateElement(element) {
				var l10n = getL10nAttributes(element);
				if (!l10n.id)
					return;
				var data = getL10nData(l10n.id, l10n.args);
				if (!data) {
					console.warn('#' + l10n.id + ' is undefined.');
					return;
				}
				if (data[gTextProp]) {
					if (getChildElementCount(element) === 0) {
						element[gTextProp] = data[gTextProp];
					} else {
						var children = element.childNodes;
						var found = false;
						for (var i = 0, l = children.length; i < l; i++) {
							if (children[i].nodeType === 3 && /\S/.test(children[i].nodeValue)) {
								if (found) {
									children[i].nodeValue = '';
								} else {
									children[i].nodeValue = data[gTextProp];
									found = true;
								}
							}
						}
						if (!found) {
							var textNode = document.createTextNode(data[gTextProp]);
							element.insertBefore(textNode, element.firstChild);
						}
					}
					delete data[gTextProp];
				}
				for (var k in data) {
					element[k] = data[k];
				}
			}

			function getChildElementCount(element) {
				if (element.children) {
					return element.children.length;
				}
				if (typeof element.childElementCount !== 'undefined') {
					return element.childElementCount;
				}
				var count = 0;
				for (var i = 0; i < element.childNodes.length; i++) {
					count += element.nodeType === 1 ? 1 : 0;
				}
				return count;
			}

			function translateFragment(element) {
				element = element || document.documentElement;
				var children = getTranslatableChildren(element);
				var elementCount = children.length;
				for (var i = 0; i < elementCount; i++) {
					translateElement(children[i]);
				}
				translateElement(element);
			}
			return {
				get: function get(key, args, fallbackString) {
					var index = key.lastIndexOf('.');
					var prop = gTextProp;
					if (index > 0) {
						prop = key.substr(index + 1);
						key = key.substring(0, index);
					}
					var fallback;
					if (fallbackString) {
						fallback = {};
						fallback[prop] = fallbackString;
					}
					var data = getL10nData(key, args, fallback);
					if (data && prop in data) {
						return data[prop];
					}
					return '{{' + key + '}}';
				},
				getData: function getData() {
					return gL10nData;
				},
				getText: function getText() {
					return gTextData;
				},
				getLanguage: function getLanguage() {
					return gLanguage;
				},
				setLanguage: function setLanguage(lang, callback) {
					loadLocale(lang, function() {
						if (callback)
							callback();
					});
				},
				getDirection: function getDirection() {
					var rtlList = ['ar', 'he', 'fa', 'ps', 'ur'];
					var shortCode = gLanguage.split('-', 1)[0];
					return rtlList.indexOf(shortCode) >= 0 ? 'rtl' : 'ltr';
				},
				translate: translateFragment,
				getReadyState: function getReadyState() {
					return gReadyState;
				},
				ready: function ready(callback) {
					if (!callback) {
						return;
					} else if (gReadyState == 'complete' || gReadyState == 'interactive') {
						window.setTimeout(function() {
							callback();
						});
					} else if (document.addEventListener) {
						document.addEventListener('localized', function once() {
							document.removeEventListener('localized', once);
							callback();
						});
					}
				}
			};
		}(window, document);
	}), /* 34 */
	(function(module, exports, __webpack_require__) {
		"use strict";
		Object.defineProperty(exports, "__esModule", {
			value: true
		});
		exports.PDFPrintService = undefined;
		var _ui_utils = __webpack_require__(0);
		var _app = __webpack_require__(4);
		var _pdfjsLib = __webpack_require__(1);
		var activeService = null;
		var overlayManager = null;

		function renderPage(activeServiceOnEntry, pdfDocument, pageNumber, size) {
			var scratchCanvas = activeService.scratchCanvas;
			var PRINT_RESOLUTION = 150;
			var PRINT_UNITS = PRINT_RESOLUTION / 72.0;
			scratchCanvas.width = Math.floor(size.width * PRINT_UNITS);
			scratchCanvas.height = Math.floor(size.height * PRINT_UNITS);
			var width = Math.floor(size.width * _ui_utils.CSS_UNITS) + 'px';
			var height = Math.floor(size.height * _ui_utils.CSS_UNITS) + 'px';
			var ctx = scratchCanvas.getContext('2d');
			ctx.save();
			ctx.fillStyle = 'rgb(255, 255, 255)';
			ctx.fillRect(0, 0, scratchCanvas.width, scratchCanvas.height);
			ctx.restore();
			return pdfDocument.getPage(pageNumber).then(function(pdfPage) {
				var renderContext = {
					canvasContext: ctx,
					transform: [PRINT_UNITS, 0, 0, PRINT_UNITS, 0, 0],
					viewport: pdfPage.getViewport(1, size.rotation),
					intent: 'print'
				};
				return pdfPage.render(renderContext).promise;
			}).then(function() {
				return {
					width: width,
					height: height
				};
			});
		}

		function PDFPrintService(pdfDocument, pagesOverview, printContainer, l10n) {
			this.pdfDocument = pdfDocument;
			this.pagesOverview = pagesOverview;
			this.printContainer = printContainer;
			this.l10n = l10n || _ui_utils.NullL10n;
			this.currentPage = -1;
			this.scratchCanvas = document.createElement('canvas');
		}
		PDFPrintService.prototype = {
			layout: function layout() {
				this.throwIfInactive();
				var body = document.querySelector('body');
				body.setAttribute('data-pdfjsprinting', true);
				var hasEqualPageSizes = this.pagesOverview.every(function(size) {
					return size.width === this.pagesOverview[0].width && size.height === this
						.pagesOverview[0].height;
				}, this);
				if (!hasEqualPageSizes) {
					console.warn('Not all pages have the same size. The printed ' +
						'result may be incorrect!');
				}
				this.pageStyleSheet = document.createElement('style');
				var pageSize = this.pagesOverview[0];
				this.pageStyleSheet.textContent = '@supports ((size:A4) and (size:1pt 1pt)) {' +
					'@page { size: ' + pageSize.width + 'pt ' + pageSize.height + 'pt;}' + '}';
				body.appendChild(this.pageStyleSheet);
			},
			destroy: function destroy() {
				if (activeService !== this) {
					return;
				}
				this.printContainer.textContent = '';
				if (this.pageStyleSheet && this.pageStyleSheet.parentNode) {
					this.pageStyleSheet.parentNode.removeChild(this.pageStyleSheet);
					this.pageStyleSheet = null;
				}
				this.scratchCanvas.width = this.scratchCanvas.height = 0;
				this.scratchCanvas = null;
				activeService = null;
				ensureOverlay().then(function() {
					if (overlayManager.active !== 'printServiceOverlay') {
						return;
					}
					overlayManager.close('printServiceOverlay');
				});
			},
			renderPages: function renderPages() {
				var _this = this;
				var pageCount = this.pagesOverview.length;
				var renderNextPage = function renderNextPage(resolve, reject) {
					_this.throwIfInactive();
					if (++_this.currentPage >= pageCount) {
						renderProgress(pageCount, pageCount, _this.l10n);
						resolve();
						return;
					}
					var index = _this.currentPage;
					renderProgress(index, pageCount, _this.l10n);
					renderPage(_this, _this.pdfDocument, index + 1, _this.pagesOverview[index])
						.then(_this.useRenderedPage.bind(_this)).then(function() {
							renderNextPage(resolve, reject);
						}, reject);
				};
				return new Promise(renderNextPage);
			},
			useRenderedPage: function useRenderedPage(printItem) {
				this.throwIfInactive();
				var img = document.createElement('img');
				img.style.width = printItem.width;
				img.style.height = printItem.height;
				var scratchCanvas = this.scratchCanvas;
				if ('toBlob' in scratchCanvas && !_pdfjsLib.PDFJS.disableCreateObjectURL) {
					scratchCanvas.toBlob(function(blob) {
						img.src = URL.createObjectURL(blob);
					});
				} else {
					img.src = scratchCanvas.toDataURL();
				}
				var wrapper = document.createElement('div');
				wrapper.appendChild(img);
				this.printContainer.appendChild(wrapper);
				return new Promise(function(resolve, reject) {
					img.onload = resolve;
					img.onerror = reject;
				});
			},
			performPrint: function performPrint() {
				var _this2 = this;
				this.throwIfInactive();
				return new Promise(function(resolve) {
					setTimeout(function() {
						if (!_this2.active) {
							resolve();
							return;
						}
						print.call(window);
						setTimeout(resolve, 20);
					}, 0);
				});
			},
			get active() {
				return this === activeService;
			},
			throwIfInactive: function throwIfInactive() {
				if (!this.active) {
					throw new Error('This print request was cancelled or completed.');
				}
			}
		};
		var print = window.print;
		window.print = function print() {
			if (activeService) {
				console.warn('Ignored window.print() because of a pending print job.');
				return;
			}
			ensureOverlay().then(function() {
				if (activeService) {
					overlayManager.open('printServiceOverlay');
				}
			});
			try {
				dispatchEvent('beforeprint');
			} finally {
				if (!activeService) {
					console.error('Expected print service to be initialized.');
					ensureOverlay().then(function() {
						if (overlayManager.active === 'printServiceOverlay') {
							overlayManager.close('printServiceOverlay');
						}
					});
					return;
				}
				var activeServiceOnEntry = activeService;
				activeService.renderPages().then(function() {
					return activeServiceOnEntry.performPrint();
				}).catch(function() {}).then(function() {
					if (activeServiceOnEntry.active) {
						abort();
					}
				});
			}
		};

		function dispatchEvent(eventType) {
			var event = document.createEvent('CustomEvent');
			event.initCustomEvent(eventType, false, false, 'custom');
			window.dispatchEvent(event);
		}

		function abort() {
			if (activeService) {
				activeService.destroy();
				dispatchEvent('afterprint');
			}
		}

		function renderProgress(index, total, l10n) {
			var progressContainer = document.getElementById('printServiceOverlay');
			var progress = Math.round(100 * index / total);
			var progressBar = progressContainer.querySelector('progress');
			var progressPerc = progressContainer.querySelector('.relative-progress');
			progressBar.value = progress;
			l10n.get('print_progress_percent', {
				progress: progress
			}, progress + '%').then(function(msg) {
				progressPerc.textContent = msg;
			});
		}
		var hasAttachEvent = !!document.attachEvent;
		window.addEventListener('keydown', function(event) {
			if (event.keyCode === 80 && (event.ctrlKey || event.metaKey) && !event.altKey && (!event
					.shiftKey || window.chrome || window.opera)) {
				window.print();
				if (hasAttachEvent) {
					return;
				}
				event.preventDefault();
				if (event.stopImmediatePropagation) {
					event.stopImmediatePropagation();
				} else {
					event.stopPropagation();
				}
				return;
			}
		}, true);
		if (hasAttachEvent) {
			document.attachEvent('onkeydown', function(event) {
				event = event || window.event;
				if (event.keyCode === 80 && event.ctrlKey) {
					event.keyCode = 0;
					return false;
				}
			});
		}
		if ('onbeforeprint' in window) {
			var stopPropagationIfNeeded = function stopPropagationIfNeeded(event) {
				if (event.detail !== 'custom' && event.stopImmediatePropagation) {
					event.stopImmediatePropagation();
				}
			};
			window.addEventListener('beforeprint', stopPropagationIfNeeded);
			window.addEventListener('afterprint', stopPropagationIfNeeded);
		}
		var overlayPromise = void 0;

		function ensureOverlay() {
			if (!overlayPromise) {
				overlayManager = _app.PDFViewerApplication.overlayManager;
				if (!overlayManager) {
					throw new Error('The overlay manager has not yet been initialized.');
				}
				overlayPromise = overlayManager.register('printServiceOverlay', document.getElementById(
					'printServiceOverlay'), abort, true);
				document.getElementById('printCancel').onclick = abort;
			}
			return overlayPromise;
		}
		_app.PDFPrintServiceFactory.instance = {
			supportsPrinting: true,
			createPrintService: function createPrintService(pdfDocument, pagesOverview, printContainer,
				l10n) {
				if (activeService) {
					throw new Error('The print service is created and active.');
				}
				activeService = new PDFPrintService(pdfDocument, pagesOverview, printContainer, l10n);
				return activeService;
			}
		};
		exports.PDFPrintService = PDFPrintService;
	})
]);